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

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

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

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 _blocks_swig0.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 _blocks_swig0.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 _blocks_swig0.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 _blocks_swig0.high_res_timer_epoch()
class annotator_1to1(object):
    r"""Proxy of C++ gr::blocks::annotator_1to1 class."""

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

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

    @staticmethod
    def make(when: "int", sizeof_stream_item: "size_t") -> "gr::blocks::annotator_1to1::sptr":
        r"""make(int when, size_t sizeof_stream_item) -> annotator_1to1_sptr"""
        return _blocks_swig0.annotator_1to1_make(when, sizeof_stream_item)

    def data(self) -> "std::vector< gr::tag_t,std::allocator< gr::tag_t > >":
        r"""data(annotator_1to1 self) -> tags_vector_t"""
        return _blocks_swig0.annotator_1to1_data(self)
    __swig_destroy__ = _blocks_swig0.delete_annotator_1to1

# Register annotator_1to1 in _blocks_swig0:
_blocks_swig0.annotator_1to1_swigregister(annotator_1to1)

def annotator_1to1_make(when: "int", sizeof_stream_item: "size_t") -> "gr::blocks::annotator_1to1::sptr":
    r"""annotator_1to1_make(int when, size_t sizeof_stream_item) -> annotator_1to1_sptr"""
    return _blocks_swig0.annotator_1to1_make(when, sizeof_stream_item)

class annotator_alltoall(object):
    r"""Proxy of C++ gr::blocks::annotator_alltoall class."""

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

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

    @staticmethod
    def make(when: "int", sizeof_stream_item: "size_t") -> "gr::blocks::annotator_alltoall::sptr":
        r"""make(int when, size_t sizeof_stream_item) -> annotator_alltoall_sptr"""
        return _blocks_swig0.annotator_alltoall_make(when, sizeof_stream_item)

    def data(self) -> "std::vector< gr::tag_t,std::allocator< gr::tag_t > >":
        r"""data(annotator_alltoall self) -> tags_vector_t"""
        return _blocks_swig0.annotator_alltoall_data(self)
    __swig_destroy__ = _blocks_swig0.delete_annotator_alltoall

# Register annotator_alltoall in _blocks_swig0:
_blocks_swig0.annotator_alltoall_swigregister(annotator_alltoall)

def annotator_alltoall_make(when: "int", sizeof_stream_item: "size_t") -> "gr::blocks::annotator_alltoall::sptr":
    r"""annotator_alltoall_make(int when, size_t sizeof_stream_item) -> annotator_alltoall_sptr"""
    return _blocks_swig0.annotator_alltoall_make(when, sizeof_stream_item)

class annotator_raw(object):
    r"""Proxy of C++ gr::blocks::annotator_raw class."""

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

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

    @staticmethod
    def make(sizeof_stream_item: "size_t") -> "gr::blocks::annotator_raw::sptr":
        r"""make(size_t sizeof_stream_item) -> annotator_raw_sptr"""
        return _blocks_swig0.annotator_raw_make(sizeof_stream_item)

    def add_tag(self, offset: "uint64_t", key: "swig_pmt_ptr", val: "swig_pmt_ptr") -> "void":
        r"""add_tag(annotator_raw self, uint64_t offset, swig_pmt_ptr key, swig_pmt_ptr val)"""
        return _blocks_swig0.annotator_raw_add_tag(self, offset, key, val)
    __swig_destroy__ = _blocks_swig0.delete_annotator_raw

# Register annotator_raw in _blocks_swig0:
_blocks_swig0.annotator_raw_swigregister(annotator_raw)

def annotator_raw_make(sizeof_stream_item: "size_t") -> "gr::blocks::annotator_raw::sptr":
    r"""annotator_raw_make(size_t sizeof_stream_item) -> annotator_raw_sptr"""
    return _blocks_swig0.annotator_raw_make(sizeof_stream_item)

class control_loop(object):
    r"""Proxy of C++ gr::blocks::control_loop 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__(control_loop self) -> control_loop
        __init__(control_loop self, float loop_bw, float max_freq, float min_freq) -> control_loop
        """
        _blocks_swig0.control_loop_swiginit(self, _blocks_swig0.new_control_loop(*args))
    __swig_destroy__ = _blocks_swig0.delete_control_loop

    def update_gains(self) -> "void":
        r"""update_gains(control_loop self)"""
        return _blocks_swig0.control_loop_update_gains(self)

    def advance_loop(self, error: "float") -> "void":
        r"""advance_loop(control_loop self, float error)"""
        return _blocks_swig0.control_loop_advance_loop(self, error)

    def phase_wrap(self) -> "void":
        r"""phase_wrap(control_loop self)"""
        return _blocks_swig0.control_loop_phase_wrap(self)

    def frequency_limit(self) -> "void":
        r"""frequency_limit(control_loop self)"""
        return _blocks_swig0.control_loop_frequency_limit(self)

    def set_loop_bandwidth(self, bw: "float") -> "void":
        r"""set_loop_bandwidth(control_loop self, float bw)"""
        return _blocks_swig0.control_loop_set_loop_bandwidth(self, bw)

    def set_damping_factor(self, df: "float") -> "void":
        r"""set_damping_factor(control_loop self, float df)"""
        return _blocks_swig0.control_loop_set_damping_factor(self, df)

    def set_alpha(self, alpha: "float") -> "void":
        r"""set_alpha(control_loop self, float alpha)"""
        return _blocks_swig0.control_loop_set_alpha(self, alpha)

    def set_beta(self, beta: "float") -> "void":
        r"""set_beta(control_loop self, float beta)"""
        return _blocks_swig0.control_loop_set_beta(self, beta)

    def set_frequency(self, freq: "float") -> "void":
        r"""set_frequency(control_loop self, float freq)"""
        return _blocks_swig0.control_loop_set_frequency(self, freq)

    def set_phase(self, phase: "float") -> "void":
        r"""set_phase(control_loop self, float phase)"""
        return _blocks_swig0.control_loop_set_phase(self, phase)

    def set_max_freq(self, freq: "float") -> "void":
        r"""set_max_freq(control_loop self, float freq)"""
        return _blocks_swig0.control_loop_set_max_freq(self, freq)

    def set_min_freq(self, freq: "float") -> "void":
        r"""set_min_freq(control_loop self, float freq)"""
        return _blocks_swig0.control_loop_set_min_freq(self, freq)

    def get_loop_bandwidth(self) -> "float":
        r"""get_loop_bandwidth(control_loop self) -> float"""
        return _blocks_swig0.control_loop_get_loop_bandwidth(self)

    def get_damping_factor(self) -> "float":
        r"""get_damping_factor(control_loop self) -> float"""
        return _blocks_swig0.control_loop_get_damping_factor(self)

    def get_alpha(self) -> "float":
        r"""get_alpha(control_loop self) -> float"""
        return _blocks_swig0.control_loop_get_alpha(self)

    def get_beta(self) -> "float":
        r"""get_beta(control_loop self) -> float"""
        return _blocks_swig0.control_loop_get_beta(self)

    def get_frequency(self) -> "float":
        r"""get_frequency(control_loop self) -> float"""
        return _blocks_swig0.control_loop_get_frequency(self)

    def get_phase(self) -> "float":
        r"""get_phase(control_loop self) -> float"""
        return _blocks_swig0.control_loop_get_phase(self)

    def get_max_freq(self) -> "float":
        r"""get_max_freq(control_loop self) -> float"""
        return _blocks_swig0.control_loop_get_max_freq(self)

    def get_min_freq(self) -> "float":
        r"""get_min_freq(control_loop self) -> float"""
        return _blocks_swig0.control_loop_get_min_freq(self)

# Register control_loop in _blocks_swig0:
_blocks_swig0.control_loop_swigregister(control_loop)


def tanhf_lut(x: "float") -> "float":
    r"""tanhf_lut(float x) -> float"""
    return _blocks_swig0.tanhf_lut(x)
class copy(object):
    r"""Proxy of C++ gr::blocks::copy class."""

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

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

    @staticmethod
    def make(itemsize: "size_t") -> "gr::blocks::copy::sptr":
        r"""make(size_t itemsize) -> copy_sptr"""
        return _blocks_swig0.copy_make(itemsize)

    def set_enabled(self, enable: "bool") -> "void":
        r"""set_enabled(copy self, bool enable)"""
        return _blocks_swig0.copy_set_enabled(self, enable)

    def enabled(self) -> "bool":
        r"""enabled(copy self) -> bool"""
        return _blocks_swig0.copy_enabled(self)
    __swig_destroy__ = _blocks_swig0.delete_copy

# Register copy in _blocks_swig0:
_blocks_swig0.copy_swigregister(copy)
cvar = _blocks_swig0.cvar

def copy_make(itemsize: "size_t") -> "gr::blocks::copy::sptr":
    r"""copy_make(size_t itemsize) -> copy_sptr"""
    return _blocks_swig0.copy_make(itemsize)

class delay(object):
    r"""Proxy of C++ gr::blocks::delay class."""

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

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

    @staticmethod
    def make(itemsize: "size_t", delay: "int") -> "gr::blocks::delay::sptr":
        r"""make(size_t itemsize, int delay) -> delay_sptr"""
        return _blocks_swig0.delay_make(itemsize, delay)

    def dly(self) -> "int":
        r"""dly(delay self) -> int"""
        return _blocks_swig0.delay_dly(self)

    def set_dly(self, d: "int") -> "void":
        r"""set_dly(delay self, int d)"""
        return _blocks_swig0.delay_set_dly(self, d)
    __swig_destroy__ = _blocks_swig0.delete_delay

# Register delay in _blocks_swig0:
_blocks_swig0.delay_swigregister(delay)

def delay_make(itemsize: "size_t", delay: "int") -> "gr::blocks::delay::sptr":
    r"""delay_make(size_t itemsize, int delay) -> delay_sptr"""
    return _blocks_swig0.delay_make(itemsize, delay)

class endian_swap(object):
    r"""Proxy of C++ gr::blocks::endian_swap class."""

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

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

    @staticmethod
    def make(item_size_bytes: "size_t"=1) -> "gr::blocks::endian_swap::sptr":
        r"""make(size_t item_size_bytes=1) -> endian_swap_sptr"""
        return _blocks_swig0.endian_swap_make(item_size_bytes)
    __swig_destroy__ = _blocks_swig0.delete_endian_swap

# Register endian_swap in _blocks_swig0:
_blocks_swig0.endian_swap_swigregister(endian_swap)

def endian_swap_make(item_size_bytes: "size_t"=1) -> "gr::blocks::endian_swap::sptr":
    r"""endian_swap_make(size_t item_size_bytes=1) -> endian_swap_sptr"""
    return _blocks_swig0.endian_swap_make(item_size_bytes)

class file_descriptor_sink(object):
    r"""Proxy of C++ gr::blocks::file_descriptor_sink class."""

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

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

    @staticmethod
    def make(itemsize: "size_t", fd: "int") -> "gr::blocks::file_descriptor_sink::sptr":
        r"""make(size_t itemsize, int fd) -> file_descriptor_sink_sptr"""
        return _blocks_swig0.file_descriptor_sink_make(itemsize, fd)
    __swig_destroy__ = _blocks_swig0.delete_file_descriptor_sink

# Register file_descriptor_sink in _blocks_swig0:
_blocks_swig0.file_descriptor_sink_swigregister(file_descriptor_sink)

def file_descriptor_sink_make(itemsize: "size_t", fd: "int") -> "gr::blocks::file_descriptor_sink::sptr":
    r"""file_descriptor_sink_make(size_t itemsize, int fd) -> file_descriptor_sink_sptr"""
    return _blocks_swig0.file_descriptor_sink_make(itemsize, fd)

class file_descriptor_source(object):
    r"""Proxy of C++ gr::blocks::file_descriptor_source class."""

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

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

    @staticmethod
    def make(itemsize: "size_t", fd: "int", repeat: "bool"=False) -> "gr::blocks::file_descriptor_source::sptr":
        r"""make(size_t itemsize, int fd, bool repeat=False) -> file_descriptor_source_sptr"""
        return _blocks_swig0.file_descriptor_source_make(itemsize, fd, repeat)
    __swig_destroy__ = _blocks_swig0.delete_file_descriptor_source

# Register file_descriptor_source in _blocks_swig0:
_blocks_swig0.file_descriptor_source_swigregister(file_descriptor_source)

def file_descriptor_source_make(itemsize: "size_t", fd: "int", repeat: "bool"=False) -> "gr::blocks::file_descriptor_source::sptr":
    r"""file_descriptor_source_make(size_t itemsize, int fd, bool repeat=False) -> file_descriptor_source_sptr"""
    return _blocks_swig0.file_descriptor_source_make(itemsize, fd, repeat)

class file_sink_base(object):
    r"""Proxy of C++ gr::blocks::file_sink_base class."""

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

    def __init__(self):
        r"""__init__(file_sink_base self) -> file_sink_base"""
        _blocks_swig0.file_sink_base_swiginit(self, _blocks_swig0.new_file_sink_base())
    __swig_destroy__ = _blocks_swig0.delete_file_sink_base

    def open(self, filename: "char const *") -> "bool":
        r"""open(file_sink_base self, char const * filename) -> bool"""
        return _blocks_swig0.file_sink_base_open(self, filename)

    def close(self) -> "void":
        r"""close(file_sink_base self)"""
        return _blocks_swig0.file_sink_base_close(self)

    def do_update(self) -> "void":
        r"""do_update(file_sink_base self)"""
        return _blocks_swig0.file_sink_base_do_update(self)

    def set_unbuffered(self, unbuffered: "bool") -> "void":
        r"""set_unbuffered(file_sink_base self, bool unbuffered)"""
        return _blocks_swig0.file_sink_base_set_unbuffered(self, unbuffered)

# Register file_sink_base in _blocks_swig0:
_blocks_swig0.file_sink_base_swigregister(file_sink_base)

class file_sink(file_sink_base):
    r"""Proxy of C++ gr::blocks::file_sink class."""

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

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

    @staticmethod
    def make(itemsize: "size_t", filename: "char const *", append: "bool"=False) -> "gr::blocks::file_sink::sptr":
        r"""make(size_t itemsize, char const * filename, bool append=False) -> file_sink_sptr"""
        return _blocks_swig0.file_sink_make(itemsize, filename, append)
    __swig_destroy__ = _blocks_swig0.delete_file_sink

# Register file_sink in _blocks_swig0:
_blocks_swig0.file_sink_swigregister(file_sink)

def file_sink_make(itemsize: "size_t", filename: "char const *", append: "bool"=False) -> "gr::blocks::file_sink::sptr":
    r"""file_sink_make(size_t itemsize, char const * filename, bool append=False) -> file_sink_sptr"""
    return _blocks_swig0.file_sink_make(itemsize, filename, append)

class file_source(object):
    r"""Proxy of C++ gr::blocks::file_source class."""

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

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

    @staticmethod
    def make(itemsize: "size_t", filename: "char const *", repeat: "bool"=False, offset: "uint64_t"=0, len: "uint64_t"=0) -> "gr::blocks::file_source::sptr":
        r"""make(size_t itemsize, char const * filename, bool repeat=False, uint64_t offset=0, uint64_t len=0) -> file_source_sptr"""
        return _blocks_swig0.file_source_make(itemsize, filename, repeat, offset, len)

    def seek(self, seek_point: "int64_t", whence: "int") -> "bool":
        r"""seek(file_source self, int64_t seek_point, int whence) -> bool"""
        return _blocks_swig0.file_source_seek(self, seek_point, whence)

    def open(self, filename: "char const *", repeat: "bool", offset: "uint64_t"=0, len: "uint64_t"=0) -> "void":
        r"""open(file_source self, char const * filename, bool repeat, uint64_t offset=0, uint64_t len=0)"""
        return _blocks_swig0.file_source_open(self, filename, repeat, offset, len)

    def close(self) -> "void":
        r"""close(file_source self)"""
        return _blocks_swig0.file_source_close(self)

    def set_begin_tag(self, val: "swig_pmt_ptr") -> "void":
        r"""set_begin_tag(file_source self, swig_pmt_ptr val)"""
        return _blocks_swig0.file_source_set_begin_tag(self, val)
    __swig_destroy__ = _blocks_swig0.delete_file_source

# Register file_source in _blocks_swig0:
_blocks_swig0.file_source_swigregister(file_source)

def file_source_make(itemsize: "size_t", filename: "char const *", repeat: "bool"=False, offset: "uint64_t"=0, len: "uint64_t"=0) -> "gr::blocks::file_source::sptr":
    r"""file_source_make(size_t itemsize, char const * filename, bool repeat=False, uint64_t offset=0, uint64_t len=0) -> file_source_sptr"""
    return _blocks_swig0.file_source_make(itemsize, filename, repeat, offset, len)

GR_FILE_BYTE = _blocks_swig0.GR_FILE_BYTE

GR_FILE_CHAR = _blocks_swig0.GR_FILE_CHAR

GR_FILE_SHORT = _blocks_swig0.GR_FILE_SHORT

GR_FILE_INT = _blocks_swig0.GR_FILE_INT

GR_FILE_LONG = _blocks_swig0.GR_FILE_LONG

GR_FILE_LONG_LONG = _blocks_swig0.GR_FILE_LONG_LONG

GR_FILE_FLOAT = _blocks_swig0.GR_FILE_FLOAT

GR_FILE_DOUBLE = _blocks_swig0.GR_FILE_DOUBLE

class file_meta_sink(object):
    r"""Proxy of C++ gr::blocks::file_meta_sink class."""

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

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

    @staticmethod
    def make(*args, **kwargs) -> "gr::blocks::file_meta_sink::sptr":
        r"""make(size_t itemsize, std::string const & filename, double samp_rate=1, double relative_rate=1, gr::blocks::gr_file_types type=GR_FILE_FLOAT, bool complex=True, size_t max_segment_size=1000000, swig_pmt_ptr extra_dict=pmt::make_dict(), bool detached_header=False) -> file_meta_sink_sptr"""
        return _blocks_swig0.file_meta_sink_make(*args, **kwargs)

    def open(self, filename: "std::string const &") -> "bool":
        r"""open(file_meta_sink self, std::string const & filename) -> bool"""
        return _blocks_swig0.file_meta_sink_open(self, filename)

    def close(self) -> "void":
        r"""close(file_meta_sink self)"""
        return _blocks_swig0.file_meta_sink_close(self)

    def do_update(self) -> "void":
        r"""do_update(file_meta_sink self)"""
        return _blocks_swig0.file_meta_sink_do_update(self)

    def set_unbuffered(self, unbuffered: "bool") -> "void":
        r"""set_unbuffered(file_meta_sink self, bool unbuffered)"""
        return _blocks_swig0.file_meta_sink_set_unbuffered(self, unbuffered)
    __swig_destroy__ = _blocks_swig0.delete_file_meta_sink

# Register file_meta_sink in _blocks_swig0:
_blocks_swig0.file_meta_sink_swigregister(file_meta_sink)
METADATA_VERSION = cvar.METADATA_VERSION
METADATA_HEADER_SIZE = cvar.METADATA_HEADER_SIZE

def file_meta_sink_make(*args, **kwargs) -> "gr::blocks::file_meta_sink::sptr":
    r"""file_meta_sink_make(size_t itemsize, std::string const & filename, double samp_rate=1, double relative_rate=1, gr::blocks::gr_file_types type=GR_FILE_FLOAT, bool complex=True, size_t max_segment_size=1000000, swig_pmt_ptr extra_dict=pmt::make_dict(), bool detached_header=False) -> file_meta_sink_sptr"""
    return _blocks_swig0.file_meta_sink_make(*args, **kwargs)

class file_meta_source(object):
    r"""Proxy of C++ gr::blocks::file_meta_source class."""

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

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

    @staticmethod
    def make(*args, **kwargs) -> "gr::blocks::file_meta_source::sptr":
        r"""make(std::string const & filename, bool repeat=False, bool detached_header=False, std::string const & hdr_filename="") -> file_meta_source_sptr"""
        return _blocks_swig0.file_meta_source_make(*args, **kwargs)

    def open(self, *args, **kwargs) -> "bool":
        r"""open(file_meta_source self, std::string const & filename, std::string const & hdr_filename="") -> bool"""
        return _blocks_swig0.file_meta_source_open(self, *args, **kwargs)

    def close(self) -> "void":
        r"""close(file_meta_source self)"""
        return _blocks_swig0.file_meta_source_close(self)

    def do_update(self) -> "void":
        r"""do_update(file_meta_source self)"""
        return _blocks_swig0.file_meta_source_do_update(self)
    __swig_destroy__ = _blocks_swig0.delete_file_meta_source

# Register file_meta_source in _blocks_swig0:
_blocks_swig0.file_meta_source_swigregister(file_meta_source)

def file_meta_source_make(*args, **kwargs) -> "gr::blocks::file_meta_source::sptr":
    r"""file_meta_source_make(std::string const & filename, bool repeat=False, bool detached_header=False, std::string const & hdr_filename="") -> file_meta_source_sptr"""
    return _blocks_swig0.file_meta_source_make(*args, **kwargs)

class head(object):
    r"""Proxy of C++ gr::blocks::head class."""

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

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

    @staticmethod
    def make(sizeof_stream_item: "size_t", nitems: "uint64_t") -> "gr::blocks::head::sptr":
        r"""make(size_t sizeof_stream_item, uint64_t nitems) -> head_sptr"""
        return _blocks_swig0.head_make(sizeof_stream_item, nitems)

    def reset(self) -> "void":
        r"""reset(head self)"""
        return _blocks_swig0.head_reset(self)

    def set_length(self, nitems: "uint64_t") -> "void":
        r"""set_length(head self, uint64_t nitems)"""
        return _blocks_swig0.head_set_length(self, nitems)
    __swig_destroy__ = _blocks_swig0.delete_head

# Register head in _blocks_swig0:
_blocks_swig0.head_swigregister(head)

def head_make(sizeof_stream_item: "size_t", nitems: "uint64_t") -> "gr::blocks::head::sptr":
    r"""head_make(size_t sizeof_stream_item, uint64_t nitems) -> head_sptr"""
    return _blocks_swig0.head_make(sizeof_stream_item, nitems)

class message_debug(object):
    r"""Proxy of C++ gr::blocks::message_debug class."""

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

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

    @staticmethod
    def make() -> "gr::blocks::message_debug::sptr":
        r"""make() -> message_debug_sptr"""
        return _blocks_swig0.message_debug_make()

    def num_messages(self) -> "int":
        r"""num_messages(message_debug self) -> int"""
        return _blocks_swig0.message_debug_num_messages(self)

    def get_message(self, i: "int") -> "pmt::pmt_t":
        r"""get_message(message_debug self, int i) -> swig_pmt_ptr"""
        return _blocks_swig0.message_debug_get_message(self, i)
    __swig_destroy__ = _blocks_swig0.delete_message_debug

# Register message_debug in _blocks_swig0:
_blocks_swig0.message_debug_swigregister(message_debug)

def message_debug_make() -> "gr::blocks::message_debug::sptr":
    r"""message_debug_make() -> message_debug_sptr"""
    return _blocks_swig0.message_debug_make()

class message_strobe(object):
    r"""Proxy of C++ gr::blocks::message_strobe class."""

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

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

    @staticmethod
    def make(msg: "swig_pmt_ptr", period_ms: "long") -> "gr::blocks::message_strobe::sptr":
        r"""make(swig_pmt_ptr msg, long period_ms) -> message_strobe_sptr"""
        return _blocks_swig0.message_strobe_make(msg, period_ms)

    def set_msg(self, msg: "swig_pmt_ptr") -> "void":
        r"""set_msg(message_strobe self, swig_pmt_ptr msg)"""
        return _blocks_swig0.message_strobe_set_msg(self, msg)

    def msg(self) -> "pmt::pmt_t":
        r"""msg(message_strobe self) -> swig_pmt_ptr"""
        return _blocks_swig0.message_strobe_msg(self)

    def set_period(self, period_ms: "long") -> "void":
        r"""set_period(message_strobe self, long period_ms)"""
        return _blocks_swig0.message_strobe_set_period(self, period_ms)

    def period(self) -> "long":
        r"""period(message_strobe self) -> long"""
        return _blocks_swig0.message_strobe_period(self)
    __swig_destroy__ = _blocks_swig0.delete_message_strobe

# Register message_strobe in _blocks_swig0:
_blocks_swig0.message_strobe_swigregister(message_strobe)

def message_strobe_make(msg: "swig_pmt_ptr", period_ms: "long") -> "gr::blocks::message_strobe::sptr":
    r"""message_strobe_make(swig_pmt_ptr msg, long period_ms) -> message_strobe_sptr"""
    return _blocks_swig0.message_strobe_make(msg, period_ms)

STROBE_POISSON = _blocks_swig0.STROBE_POISSON

STROBE_GAUSSIAN = _blocks_swig0.STROBE_GAUSSIAN

STROBE_UNIFORM = _blocks_swig0.STROBE_UNIFORM

class message_strobe_random(object):
    r"""Proxy of C++ gr::blocks::message_strobe_random class."""

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

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

    @staticmethod
    def make(msg: "swig_pmt_ptr", dist: "gr::blocks::message_strobe_random_distribution_t", mean_ms: "float", std_ms: "float") -> "gr::blocks::message_strobe_random::sptr":
        r"""make(swig_pmt_ptr msg, gr::blocks::message_strobe_random_distribution_t dist, float mean_ms, float std_ms) -> message_strobe_random_sptr"""
        return _blocks_swig0.message_strobe_random_make(msg, dist, mean_ms, std_ms)

    def set_msg(self, msg: "swig_pmt_ptr") -> "void":
        r"""set_msg(message_strobe_random self, swig_pmt_ptr msg)"""
        return _blocks_swig0.message_strobe_random_set_msg(self, msg)

    def msg(self) -> "pmt::pmt_t":
        r"""msg(message_strobe_random self) -> swig_pmt_ptr"""
        return _blocks_swig0.message_strobe_random_msg(self)

    def set_dist(self, dist: "gr::blocks::message_strobe_random_distribution_t") -> "void":
        r"""set_dist(message_strobe_random self, gr::blocks::message_strobe_random_distribution_t dist)"""
        return _blocks_swig0.message_strobe_random_set_dist(self, dist)

    def dist(self) -> "gr::blocks::message_strobe_random_distribution_t":
        r"""dist(message_strobe_random self) -> gr::blocks::message_strobe_random_distribution_t"""
        return _blocks_swig0.message_strobe_random_dist(self)

    def set_mean(self, mean: "float") -> "void":
        r"""set_mean(message_strobe_random self, float mean)"""
        return _blocks_swig0.message_strobe_random_set_mean(self, mean)

    def mean(self) -> "float":
        r"""mean(message_strobe_random self) -> float"""
        return _blocks_swig0.message_strobe_random_mean(self)

    def set_std(self, std: "float") -> "void":
        r"""set_std(message_strobe_random self, float std)"""
        return _blocks_swig0.message_strobe_random_set_std(self, std)

    def std(self) -> "float":
        r"""std(message_strobe_random self) -> float"""
        return _blocks_swig0.message_strobe_random_std(self)
    __swig_destroy__ = _blocks_swig0.delete_message_strobe_random

# Register message_strobe_random in _blocks_swig0:
_blocks_swig0.message_strobe_random_swigregister(message_strobe_random)

def message_strobe_random_make(msg: "swig_pmt_ptr", dist: "gr::blocks::message_strobe_random_distribution_t", mean_ms: "float", std_ms: "float") -> "gr::blocks::message_strobe_random::sptr":
    r"""message_strobe_random_make(swig_pmt_ptr msg, gr::blocks::message_strobe_random_distribution_t dist, float mean_ms, float std_ms) -> message_strobe_random_sptr"""
    return _blocks_swig0.message_strobe_random_make(msg, dist, mean_ms, std_ms)

class nop(object):
    r"""Proxy of C++ gr::blocks::nop class."""

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

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

    @staticmethod
    def make(sizeof_stream_item: "size_t") -> "gr::blocks::nop::sptr":
        r"""make(size_t sizeof_stream_item) -> nop_sptr"""
        return _blocks_swig0.nop_make(sizeof_stream_item)

    def nmsgs_received(self) -> "int":
        r"""nmsgs_received(nop self) -> int"""
        return _blocks_swig0.nop_nmsgs_received(self)

    def ctrlport_test(self) -> "int":
        r"""ctrlport_test(nop self) -> int"""
        return _blocks_swig0.nop_ctrlport_test(self)

    def set_ctrlport_test(self, x: "int") -> "void":
        r"""set_ctrlport_test(nop self, int x)"""
        return _blocks_swig0.nop_set_ctrlport_test(self, x)
    __swig_destroy__ = _blocks_swig0.delete_nop

# Register nop in _blocks_swig0:
_blocks_swig0.nop_swigregister(nop)

def nop_make(sizeof_stream_item: "size_t") -> "gr::blocks::nop::sptr":
    r"""nop_make(size_t sizeof_stream_item) -> nop_sptr"""
    return _blocks_swig0.nop_make(sizeof_stream_item)

class null_sink(object):
    r"""Proxy of C++ gr::blocks::null_sink class."""

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

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

    @staticmethod
    def make(sizeof_stream_item: "size_t") -> "gr::blocks::null_sink::sptr":
        r"""make(size_t sizeof_stream_item) -> null_sink_sptr"""
        return _blocks_swig0.null_sink_make(sizeof_stream_item)
    __swig_destroy__ = _blocks_swig0.delete_null_sink

# Register null_sink in _blocks_swig0:
_blocks_swig0.null_sink_swigregister(null_sink)

def null_sink_make(sizeof_stream_item: "size_t") -> "gr::blocks::null_sink::sptr":
    r"""null_sink_make(size_t sizeof_stream_item) -> null_sink_sptr"""
    return _blocks_swig0.null_sink_make(sizeof_stream_item)

class null_source(object):
    r"""Proxy of C++ gr::blocks::null_source class."""

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

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

    @staticmethod
    def make(sizeof_stream_item: "size_t") -> "gr::blocks::null_source::sptr":
        r"""make(size_t sizeof_stream_item) -> null_source_sptr"""
        return _blocks_swig0.null_source_make(sizeof_stream_item)
    __swig_destroy__ = _blocks_swig0.delete_null_source

# Register null_source in _blocks_swig0:
_blocks_swig0.null_source_swigregister(null_source)

def null_source_make(sizeof_stream_item: "size_t") -> "gr::blocks::null_source::sptr":
    r"""null_source_make(size_t sizeof_stream_item) -> null_source_sptr"""
    return _blocks_swig0.null_source_make(sizeof_stream_item)

class annotator_1to1_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::annotator_1to1 > 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__(annotator_1to1_sptr self) -> annotator_1to1_sptr
        __init__(annotator_1to1_sptr self, annotator_1to1 p) -> annotator_1to1_sptr
        """
        _blocks_swig0.annotator_1to1_sptr_swiginit(self, _blocks_swig0.new_annotator_1to1_sptr(*args))

    def __deref__(self) -> "gr::blocks::annotator_1to1 *":
        r"""__deref__(annotator_1to1_sptr self) -> annotator_1to1"""
        return _blocks_swig0.annotator_1to1_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig0.delete_annotator_1to1_sptr

    def make(self, when: "int", sizeof_stream_item: "size_t") -> "gr::blocks::annotator_1to1::sptr":
        r"""make(annotator_1to1_sptr self, int when, size_t sizeof_stream_item) -> annotator_1to1_sptr"""
        return _blocks_swig0.annotator_1to1_sptr_make(self, when, sizeof_stream_item)

    def data(self) -> "std::vector< gr::tag_t,std::allocator< gr::tag_t > >":
        r"""data(annotator_1to1_sptr self) -> tags_vector_t"""
        return _blocks_swig0.annotator_1to1_sptr_data(self)

    def history(self) -> "unsigned int":
        r"""history(annotator_1to1_sptr self) -> unsigned int"""
        return _blocks_swig0.annotator_1to1_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(annotator_1to1_sptr self, int which, int delay)
        declare_sample_delay(annotator_1to1_sptr self, unsigned int delay)
        """
        return _blocks_swig0.annotator_1to1_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(annotator_1to1_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.annotator_1to1_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(annotator_1to1_sptr self, int multiple)"""
        return _blocks_swig0.annotator_1to1_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(annotator_1to1_sptr self) -> int"""
        return _blocks_swig0.annotator_1to1_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(annotator_1to1_sptr self) -> double"""
        return _blocks_swig0.annotator_1to1_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(annotator_1to1_sptr self) -> uint64_t"""
        return _blocks_swig0.annotator_1to1_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(annotator_1to1_sptr self) -> uint64_t"""
        return _blocks_swig0.annotator_1to1_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(annotator_1to1_sptr self) -> bool"""
        return _blocks_swig0.annotator_1to1_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(annotator_1to1_sptr self) -> bool"""
        return _blocks_swig0.annotator_1to1_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(annotator_1to1_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.annotator_1to1_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(annotator_1to1_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.annotator_1to1_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(annotator_1to1_sptr self, std::string level)"""
        return _blocks_swig0.annotator_1to1_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(annotator_1to1_sptr self) -> std::string"""
        return _blocks_swig0.annotator_1to1_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(annotator_1to1_sptr self) -> int"""
        return _blocks_swig0.annotator_1to1_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(annotator_1to1_sptr self, int m)"""
        return _blocks_swig0.annotator_1to1_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(annotator_1to1_sptr self)"""
        return _blocks_swig0.annotator_1to1_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(annotator_1to1_sptr self) -> bool"""
        return _blocks_swig0.annotator_1to1_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(annotator_1to1_sptr self, int m)"""
        return _blocks_swig0.annotator_1to1_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(annotator_1to1_sptr self) -> int"""
        return _blocks_swig0.annotator_1to1_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(annotator_1to1_sptr self, int i) -> long"""
        return _blocks_swig0.annotator_1to1_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(annotator_1to1_sptr self, long max_output_buffer)
        set_max_output_buffer(annotator_1to1_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.annotator_1to1_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(annotator_1to1_sptr self, int i) -> long"""
        return _blocks_swig0.annotator_1to1_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(annotator_1to1_sptr self, long min_output_buffer)
        set_min_output_buffer(annotator_1to1_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.annotator_1to1_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(annotator_1to1_sptr self) -> float"""
        return _blocks_swig0.annotator_1to1_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(annotator_1to1_sptr self) -> float"""
        return _blocks_swig0.annotator_1to1_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(annotator_1to1_sptr self) -> float"""
        return _blocks_swig0.annotator_1to1_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(annotator_1to1_sptr self) -> float"""
        return _blocks_swig0.annotator_1to1_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(annotator_1to1_sptr self) -> float"""
        return _blocks_swig0.annotator_1to1_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(annotator_1to1_sptr self) -> float"""
        return _blocks_swig0.annotator_1to1_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(annotator_1to1_sptr self, int which) -> float
        pc_input_buffers_full(annotator_1to1_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.annotator_1to1_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(annotator_1to1_sptr self, int which) -> float
        pc_input_buffers_full_avg(annotator_1to1_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.annotator_1to1_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(annotator_1to1_sptr self, int which) -> float
        pc_input_buffers_full_var(annotator_1to1_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.annotator_1to1_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(annotator_1to1_sptr self, int which) -> float
        pc_output_buffers_full(annotator_1to1_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.annotator_1to1_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(annotator_1to1_sptr self, int which) -> float
        pc_output_buffers_full_avg(annotator_1to1_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.annotator_1to1_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(annotator_1to1_sptr self, int which) -> float
        pc_output_buffers_full_var(annotator_1to1_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.annotator_1to1_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(annotator_1to1_sptr self) -> float"""
        return _blocks_swig0.annotator_1to1_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(annotator_1to1_sptr self) -> float"""
        return _blocks_swig0.annotator_1to1_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(annotator_1to1_sptr self) -> float"""
        return _blocks_swig0.annotator_1to1_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(annotator_1to1_sptr self) -> float"""
        return _blocks_swig0.annotator_1to1_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(annotator_1to1_sptr self) -> float"""
        return _blocks_swig0.annotator_1to1_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(annotator_1to1_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.annotator_1to1_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(annotator_1to1_sptr self)"""
        return _blocks_swig0.annotator_1to1_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(annotator_1to1_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.annotator_1to1_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(annotator_1to1_sptr self) -> int"""
        return _blocks_swig0.annotator_1to1_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(annotator_1to1_sptr self) -> int"""
        return _blocks_swig0.annotator_1to1_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(annotator_1to1_sptr self, int priority) -> int"""
        return _blocks_swig0.annotator_1to1_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(annotator_1to1_sptr self) -> std::string"""
        return _blocks_swig0.annotator_1to1_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(annotator_1to1_sptr self) -> std::string"""
        return _blocks_swig0.annotator_1to1_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(annotator_1to1_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.annotator_1to1_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(annotator_1to1_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.annotator_1to1_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(annotator_1to1_sptr self) -> long"""
        return _blocks_swig0.annotator_1to1_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(annotator_1to1_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.annotator_1to1_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(annotator_1to1_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.annotator_1to1_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(annotator_1to1_sptr self) -> std::string"""
        return _blocks_swig0.annotator_1to1_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(annotator_1to1_sptr self, std::string name)"""
        return _blocks_swig0.annotator_1to1_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(annotator_1to1_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig0.annotator_1to1_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(annotator_1to1_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig0.annotator_1to1_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(annotator_1to1_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig0.annotator_1to1_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(annotator_1to1_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig0.annotator_1to1_sptr_message_subscribers(self, which_port)

# Register annotator_1to1_sptr in _blocks_swig0:
_blocks_swig0.annotator_1to1_sptr_swigregister(annotator_1to1_sptr)


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

class annotator_alltoall_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::annotator_alltoall > 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__(annotator_alltoall_sptr self) -> annotator_alltoall_sptr
        __init__(annotator_alltoall_sptr self, annotator_alltoall p) -> annotator_alltoall_sptr
        """
        _blocks_swig0.annotator_alltoall_sptr_swiginit(self, _blocks_swig0.new_annotator_alltoall_sptr(*args))

    def __deref__(self) -> "gr::blocks::annotator_alltoall *":
        r"""__deref__(annotator_alltoall_sptr self) -> annotator_alltoall"""
        return _blocks_swig0.annotator_alltoall_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig0.delete_annotator_alltoall_sptr

    def make(self, when: "int", sizeof_stream_item: "size_t") -> "gr::blocks::annotator_alltoall::sptr":
        r"""make(annotator_alltoall_sptr self, int when, size_t sizeof_stream_item) -> annotator_alltoall_sptr"""
        return _blocks_swig0.annotator_alltoall_sptr_make(self, when, sizeof_stream_item)

    def data(self) -> "std::vector< gr::tag_t,std::allocator< gr::tag_t > >":
        r"""data(annotator_alltoall_sptr self) -> tags_vector_t"""
        return _blocks_swig0.annotator_alltoall_sptr_data(self)

    def history(self) -> "unsigned int":
        r"""history(annotator_alltoall_sptr self) -> unsigned int"""
        return _blocks_swig0.annotator_alltoall_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(annotator_alltoall_sptr self, int which, int delay)
        declare_sample_delay(annotator_alltoall_sptr self, unsigned int delay)
        """
        return _blocks_swig0.annotator_alltoall_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(annotator_alltoall_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.annotator_alltoall_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(annotator_alltoall_sptr self, int multiple)"""
        return _blocks_swig0.annotator_alltoall_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(annotator_alltoall_sptr self) -> int"""
        return _blocks_swig0.annotator_alltoall_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(annotator_alltoall_sptr self) -> double"""
        return _blocks_swig0.annotator_alltoall_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(annotator_alltoall_sptr self) -> uint64_t"""
        return _blocks_swig0.annotator_alltoall_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(annotator_alltoall_sptr self) -> uint64_t"""
        return _blocks_swig0.annotator_alltoall_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(annotator_alltoall_sptr self) -> bool"""
        return _blocks_swig0.annotator_alltoall_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(annotator_alltoall_sptr self) -> bool"""
        return _blocks_swig0.annotator_alltoall_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(annotator_alltoall_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.annotator_alltoall_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(annotator_alltoall_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.annotator_alltoall_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(annotator_alltoall_sptr self, std::string level)"""
        return _blocks_swig0.annotator_alltoall_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(annotator_alltoall_sptr self) -> std::string"""
        return _blocks_swig0.annotator_alltoall_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(annotator_alltoall_sptr self) -> int"""
        return _blocks_swig0.annotator_alltoall_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(annotator_alltoall_sptr self, int m)"""
        return _blocks_swig0.annotator_alltoall_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(annotator_alltoall_sptr self)"""
        return _blocks_swig0.annotator_alltoall_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(annotator_alltoall_sptr self) -> bool"""
        return _blocks_swig0.annotator_alltoall_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(annotator_alltoall_sptr self, int m)"""
        return _blocks_swig0.annotator_alltoall_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(annotator_alltoall_sptr self) -> int"""
        return _blocks_swig0.annotator_alltoall_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(annotator_alltoall_sptr self, int i) -> long"""
        return _blocks_swig0.annotator_alltoall_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(annotator_alltoall_sptr self, long max_output_buffer)
        set_max_output_buffer(annotator_alltoall_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.annotator_alltoall_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(annotator_alltoall_sptr self, int i) -> long"""
        return _blocks_swig0.annotator_alltoall_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(annotator_alltoall_sptr self, long min_output_buffer)
        set_min_output_buffer(annotator_alltoall_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.annotator_alltoall_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(annotator_alltoall_sptr self) -> float"""
        return _blocks_swig0.annotator_alltoall_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(annotator_alltoall_sptr self) -> float"""
        return _blocks_swig0.annotator_alltoall_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(annotator_alltoall_sptr self) -> float"""
        return _blocks_swig0.annotator_alltoall_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(annotator_alltoall_sptr self) -> float"""
        return _blocks_swig0.annotator_alltoall_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(annotator_alltoall_sptr self) -> float"""
        return _blocks_swig0.annotator_alltoall_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(annotator_alltoall_sptr self) -> float"""
        return _blocks_swig0.annotator_alltoall_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(annotator_alltoall_sptr self, int which) -> float
        pc_input_buffers_full(annotator_alltoall_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.annotator_alltoall_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(annotator_alltoall_sptr self, int which) -> float
        pc_input_buffers_full_avg(annotator_alltoall_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.annotator_alltoall_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(annotator_alltoall_sptr self, int which) -> float
        pc_input_buffers_full_var(annotator_alltoall_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.annotator_alltoall_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(annotator_alltoall_sptr self, int which) -> float
        pc_output_buffers_full(annotator_alltoall_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.annotator_alltoall_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(annotator_alltoall_sptr self, int which) -> float
        pc_output_buffers_full_avg(annotator_alltoall_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.annotator_alltoall_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(annotator_alltoall_sptr self, int which) -> float
        pc_output_buffers_full_var(annotator_alltoall_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.annotator_alltoall_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(annotator_alltoall_sptr self) -> float"""
        return _blocks_swig0.annotator_alltoall_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(annotator_alltoall_sptr self) -> float"""
        return _blocks_swig0.annotator_alltoall_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(annotator_alltoall_sptr self) -> float"""
        return _blocks_swig0.annotator_alltoall_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(annotator_alltoall_sptr self) -> float"""
        return _blocks_swig0.annotator_alltoall_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(annotator_alltoall_sptr self) -> float"""
        return _blocks_swig0.annotator_alltoall_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(annotator_alltoall_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.annotator_alltoall_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(annotator_alltoall_sptr self)"""
        return _blocks_swig0.annotator_alltoall_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(annotator_alltoall_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.annotator_alltoall_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(annotator_alltoall_sptr self) -> int"""
        return _blocks_swig0.annotator_alltoall_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(annotator_alltoall_sptr self) -> int"""
        return _blocks_swig0.annotator_alltoall_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(annotator_alltoall_sptr self, int priority) -> int"""
        return _blocks_swig0.annotator_alltoall_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(annotator_alltoall_sptr self) -> std::string"""
        return _blocks_swig0.annotator_alltoall_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(annotator_alltoall_sptr self) -> std::string"""
        return _blocks_swig0.annotator_alltoall_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(annotator_alltoall_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.annotator_alltoall_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(annotator_alltoall_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.annotator_alltoall_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(annotator_alltoall_sptr self) -> long"""
        return _blocks_swig0.annotator_alltoall_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(annotator_alltoall_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.annotator_alltoall_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(annotator_alltoall_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.annotator_alltoall_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(annotator_alltoall_sptr self) -> std::string"""
        return _blocks_swig0.annotator_alltoall_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(annotator_alltoall_sptr self, std::string name)"""
        return _blocks_swig0.annotator_alltoall_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(annotator_alltoall_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig0.annotator_alltoall_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(annotator_alltoall_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig0.annotator_alltoall_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(annotator_alltoall_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig0.annotator_alltoall_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(annotator_alltoall_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig0.annotator_alltoall_sptr_message_subscribers(self, which_port)

# Register annotator_alltoall_sptr in _blocks_swig0:
_blocks_swig0.annotator_alltoall_sptr_swigregister(annotator_alltoall_sptr)


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

class annotator_raw_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::annotator_raw > 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__(annotator_raw_sptr self) -> annotator_raw_sptr
        __init__(annotator_raw_sptr self, annotator_raw p) -> annotator_raw_sptr
        """
        _blocks_swig0.annotator_raw_sptr_swiginit(self, _blocks_swig0.new_annotator_raw_sptr(*args))

    def __deref__(self) -> "gr::blocks::annotator_raw *":
        r"""__deref__(annotator_raw_sptr self) -> annotator_raw"""
        return _blocks_swig0.annotator_raw_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig0.delete_annotator_raw_sptr

    def make(self, sizeof_stream_item: "size_t") -> "gr::blocks::annotator_raw::sptr":
        r"""make(annotator_raw_sptr self, size_t sizeof_stream_item) -> annotator_raw_sptr"""
        return _blocks_swig0.annotator_raw_sptr_make(self, sizeof_stream_item)

    def add_tag(self, offset: "uint64_t", key: "swig_pmt_ptr", val: "swig_pmt_ptr") -> "void":
        r"""add_tag(annotator_raw_sptr self, uint64_t offset, swig_pmt_ptr key, swig_pmt_ptr val)"""
        return _blocks_swig0.annotator_raw_sptr_add_tag(self, offset, key, val)

    def history(self) -> "unsigned int":
        r"""history(annotator_raw_sptr self) -> unsigned int"""
        return _blocks_swig0.annotator_raw_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(annotator_raw_sptr self, int which, int delay)
        declare_sample_delay(annotator_raw_sptr self, unsigned int delay)
        """
        return _blocks_swig0.annotator_raw_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(annotator_raw_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.annotator_raw_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(annotator_raw_sptr self, int multiple)"""
        return _blocks_swig0.annotator_raw_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(annotator_raw_sptr self) -> int"""
        return _blocks_swig0.annotator_raw_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(annotator_raw_sptr self) -> double"""
        return _blocks_swig0.annotator_raw_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(annotator_raw_sptr self) -> uint64_t"""
        return _blocks_swig0.annotator_raw_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(annotator_raw_sptr self) -> uint64_t"""
        return _blocks_swig0.annotator_raw_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(annotator_raw_sptr self) -> bool"""
        return _blocks_swig0.annotator_raw_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(annotator_raw_sptr self) -> bool"""
        return _blocks_swig0.annotator_raw_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(annotator_raw_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.annotator_raw_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(annotator_raw_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.annotator_raw_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(annotator_raw_sptr self, std::string level)"""
        return _blocks_swig0.annotator_raw_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(annotator_raw_sptr self) -> std::string"""
        return _blocks_swig0.annotator_raw_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(annotator_raw_sptr self) -> int"""
        return _blocks_swig0.annotator_raw_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(annotator_raw_sptr self, int m)"""
        return _blocks_swig0.annotator_raw_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(annotator_raw_sptr self)"""
        return _blocks_swig0.annotator_raw_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(annotator_raw_sptr self) -> bool"""
        return _blocks_swig0.annotator_raw_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(annotator_raw_sptr self, int m)"""
        return _blocks_swig0.annotator_raw_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(annotator_raw_sptr self) -> int"""
        return _blocks_swig0.annotator_raw_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(annotator_raw_sptr self, int i) -> long"""
        return _blocks_swig0.annotator_raw_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(annotator_raw_sptr self, long max_output_buffer)
        set_max_output_buffer(annotator_raw_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.annotator_raw_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(annotator_raw_sptr self, int i) -> long"""
        return _blocks_swig0.annotator_raw_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(annotator_raw_sptr self, long min_output_buffer)
        set_min_output_buffer(annotator_raw_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.annotator_raw_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(annotator_raw_sptr self) -> float"""
        return _blocks_swig0.annotator_raw_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(annotator_raw_sptr self) -> float"""
        return _blocks_swig0.annotator_raw_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(annotator_raw_sptr self) -> float"""
        return _blocks_swig0.annotator_raw_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(annotator_raw_sptr self) -> float"""
        return _blocks_swig0.annotator_raw_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(annotator_raw_sptr self) -> float"""
        return _blocks_swig0.annotator_raw_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(annotator_raw_sptr self) -> float"""
        return _blocks_swig0.annotator_raw_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(annotator_raw_sptr self, int which) -> float
        pc_input_buffers_full(annotator_raw_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.annotator_raw_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(annotator_raw_sptr self, int which) -> float
        pc_input_buffers_full_avg(annotator_raw_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.annotator_raw_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(annotator_raw_sptr self, int which) -> float
        pc_input_buffers_full_var(annotator_raw_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.annotator_raw_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(annotator_raw_sptr self, int which) -> float
        pc_output_buffers_full(annotator_raw_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.annotator_raw_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(annotator_raw_sptr self, int which) -> float
        pc_output_buffers_full_avg(annotator_raw_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.annotator_raw_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(annotator_raw_sptr self, int which) -> float
        pc_output_buffers_full_var(annotator_raw_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.annotator_raw_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(annotator_raw_sptr self) -> float"""
        return _blocks_swig0.annotator_raw_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(annotator_raw_sptr self) -> float"""
        return _blocks_swig0.annotator_raw_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(annotator_raw_sptr self) -> float"""
        return _blocks_swig0.annotator_raw_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(annotator_raw_sptr self) -> float"""
        return _blocks_swig0.annotator_raw_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(annotator_raw_sptr self) -> float"""
        return _blocks_swig0.annotator_raw_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(annotator_raw_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.annotator_raw_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(annotator_raw_sptr self)"""
        return _blocks_swig0.annotator_raw_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(annotator_raw_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.annotator_raw_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(annotator_raw_sptr self) -> int"""
        return _blocks_swig0.annotator_raw_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(annotator_raw_sptr self) -> int"""
        return _blocks_swig0.annotator_raw_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(annotator_raw_sptr self, int priority) -> int"""
        return _blocks_swig0.annotator_raw_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(annotator_raw_sptr self) -> std::string"""
        return _blocks_swig0.annotator_raw_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(annotator_raw_sptr self) -> std::string"""
        return _blocks_swig0.annotator_raw_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(annotator_raw_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.annotator_raw_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(annotator_raw_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.annotator_raw_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(annotator_raw_sptr self) -> long"""
        return _blocks_swig0.annotator_raw_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(annotator_raw_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.annotator_raw_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(annotator_raw_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.annotator_raw_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(annotator_raw_sptr self) -> std::string"""
        return _blocks_swig0.annotator_raw_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(annotator_raw_sptr self, std::string name)"""
        return _blocks_swig0.annotator_raw_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(annotator_raw_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig0.annotator_raw_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(annotator_raw_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig0.annotator_raw_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(annotator_raw_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig0.annotator_raw_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(annotator_raw_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig0.annotator_raw_sptr_message_subscribers(self, which_port)

# Register annotator_raw_sptr in _blocks_swig0:
_blocks_swig0.annotator_raw_sptr_swigregister(annotator_raw_sptr)


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

class copy_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::copy > 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__(copy_sptr self) -> copy_sptr
        __init__(copy_sptr self, copy p) -> copy_sptr
        """
        _blocks_swig0.copy_sptr_swiginit(self, _blocks_swig0.new_copy_sptr(*args))

    def __deref__(self) -> "gr::blocks::copy *":
        r"""__deref__(copy_sptr self) -> copy"""
        return _blocks_swig0.copy_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig0.delete_copy_sptr

    def make(self, itemsize: "size_t") -> "gr::blocks::copy::sptr":
        r"""make(copy_sptr self, size_t itemsize) -> copy_sptr"""
        return _blocks_swig0.copy_sptr_make(self, itemsize)

    def set_enabled(self, enable: "bool") -> "void":
        r"""set_enabled(copy_sptr self, bool enable)"""
        return _blocks_swig0.copy_sptr_set_enabled(self, enable)

    def enabled(self) -> "bool":
        r"""enabled(copy_sptr self) -> bool"""
        return _blocks_swig0.copy_sptr_enabled(self)

    def history(self) -> "unsigned int":
        r"""history(copy_sptr self) -> unsigned int"""
        return _blocks_swig0.copy_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(copy_sptr self, int which, int delay)
        declare_sample_delay(copy_sptr self, unsigned int delay)
        """
        return _blocks_swig0.copy_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(copy_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.copy_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(copy_sptr self, int multiple)"""
        return _blocks_swig0.copy_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(copy_sptr self) -> int"""
        return _blocks_swig0.copy_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(copy_sptr self) -> double"""
        return _blocks_swig0.copy_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(copy_sptr self) -> uint64_t"""
        return _blocks_swig0.copy_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(copy_sptr self) -> uint64_t"""
        return _blocks_swig0.copy_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(copy_sptr self) -> bool"""
        return _blocks_swig0.copy_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(copy_sptr self) -> bool"""
        return _blocks_swig0.copy_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(copy_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.copy_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(copy_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.copy_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(copy_sptr self, std::string level)"""
        return _blocks_swig0.copy_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(copy_sptr self) -> std::string"""
        return _blocks_swig0.copy_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(copy_sptr self) -> int"""
        return _blocks_swig0.copy_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(copy_sptr self, int m)"""
        return _blocks_swig0.copy_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(copy_sptr self)"""
        return _blocks_swig0.copy_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(copy_sptr self) -> bool"""
        return _blocks_swig0.copy_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(copy_sptr self, int m)"""
        return _blocks_swig0.copy_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(copy_sptr self) -> int"""
        return _blocks_swig0.copy_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(copy_sptr self, int i) -> long"""
        return _blocks_swig0.copy_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(copy_sptr self, long max_output_buffer)
        set_max_output_buffer(copy_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.copy_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(copy_sptr self, int i) -> long"""
        return _blocks_swig0.copy_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(copy_sptr self, long min_output_buffer)
        set_min_output_buffer(copy_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.copy_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(copy_sptr self) -> float"""
        return _blocks_swig0.copy_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(copy_sptr self) -> float"""
        return _blocks_swig0.copy_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(copy_sptr self) -> float"""
        return _blocks_swig0.copy_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(copy_sptr self) -> float"""
        return _blocks_swig0.copy_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(copy_sptr self) -> float"""
        return _blocks_swig0.copy_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(copy_sptr self) -> float"""
        return _blocks_swig0.copy_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(copy_sptr self, int which) -> float
        pc_input_buffers_full(copy_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.copy_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(copy_sptr self, int which) -> float
        pc_input_buffers_full_avg(copy_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.copy_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(copy_sptr self, int which) -> float
        pc_input_buffers_full_var(copy_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.copy_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(copy_sptr self, int which) -> float
        pc_output_buffers_full(copy_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.copy_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(copy_sptr self, int which) -> float
        pc_output_buffers_full_avg(copy_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.copy_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(copy_sptr self, int which) -> float
        pc_output_buffers_full_var(copy_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.copy_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(copy_sptr self) -> float"""
        return _blocks_swig0.copy_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(copy_sptr self) -> float"""
        return _blocks_swig0.copy_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(copy_sptr self) -> float"""
        return _blocks_swig0.copy_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(copy_sptr self) -> float"""
        return _blocks_swig0.copy_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(copy_sptr self) -> float"""
        return _blocks_swig0.copy_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(copy_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.copy_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(copy_sptr self)"""
        return _blocks_swig0.copy_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(copy_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.copy_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(copy_sptr self) -> int"""
        return _blocks_swig0.copy_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(copy_sptr self) -> int"""
        return _blocks_swig0.copy_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(copy_sptr self, int priority) -> int"""
        return _blocks_swig0.copy_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(copy_sptr self) -> std::string"""
        return _blocks_swig0.copy_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(copy_sptr self) -> std::string"""
        return _blocks_swig0.copy_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(copy_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.copy_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(copy_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.copy_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(copy_sptr self) -> long"""
        return _blocks_swig0.copy_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(copy_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.copy_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(copy_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.copy_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(copy_sptr self) -> std::string"""
        return _blocks_swig0.copy_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(copy_sptr self, std::string name)"""
        return _blocks_swig0.copy_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(copy_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig0.copy_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(copy_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig0.copy_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(copy_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig0.copy_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(copy_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig0.copy_sptr_message_subscribers(self, which_port)

# Register copy_sptr in _blocks_swig0:
_blocks_swig0.copy_sptr_swigregister(copy_sptr)


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

class delay_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::delay > 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__(delay_sptr self) -> delay_sptr
        __init__(delay_sptr self, delay p) -> delay_sptr
        """
        _blocks_swig0.delay_sptr_swiginit(self, _blocks_swig0.new_delay_sptr(*args))

    def __deref__(self) -> "gr::blocks::delay *":
        r"""__deref__(delay_sptr self) -> delay"""
        return _blocks_swig0.delay_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig0.delete_delay_sptr

    def make(self, itemsize: "size_t", delay: "int") -> "gr::blocks::delay::sptr":
        r"""make(delay_sptr self, size_t itemsize, int delay) -> delay_sptr"""
        return _blocks_swig0.delay_sptr_make(self, itemsize, delay)

    def dly(self) -> "int":
        r"""dly(delay_sptr self) -> int"""
        return _blocks_swig0.delay_sptr_dly(self)

    def set_dly(self, d: "int") -> "void":
        r"""set_dly(delay_sptr self, int d)"""
        return _blocks_swig0.delay_sptr_set_dly(self, d)

    def history(self) -> "unsigned int":
        r"""history(delay_sptr self) -> unsigned int"""
        return _blocks_swig0.delay_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(delay_sptr self, int which, int delay)
        declare_sample_delay(delay_sptr self, unsigned int delay)
        """
        return _blocks_swig0.delay_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(delay_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.delay_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(delay_sptr self, int multiple)"""
        return _blocks_swig0.delay_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(delay_sptr self) -> int"""
        return _blocks_swig0.delay_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(delay_sptr self) -> double"""
        return _blocks_swig0.delay_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(delay_sptr self) -> uint64_t"""
        return _blocks_swig0.delay_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(delay_sptr self) -> uint64_t"""
        return _blocks_swig0.delay_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(delay_sptr self) -> bool"""
        return _blocks_swig0.delay_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(delay_sptr self) -> bool"""
        return _blocks_swig0.delay_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(delay_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.delay_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(delay_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.delay_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(delay_sptr self, std::string level)"""
        return _blocks_swig0.delay_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(delay_sptr self) -> std::string"""
        return _blocks_swig0.delay_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(delay_sptr self) -> int"""
        return _blocks_swig0.delay_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(delay_sptr self, int m)"""
        return _blocks_swig0.delay_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(delay_sptr self)"""
        return _blocks_swig0.delay_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(delay_sptr self) -> bool"""
        return _blocks_swig0.delay_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(delay_sptr self, int m)"""
        return _blocks_swig0.delay_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(delay_sptr self) -> int"""
        return _blocks_swig0.delay_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(delay_sptr self, int i) -> long"""
        return _blocks_swig0.delay_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(delay_sptr self, long max_output_buffer)
        set_max_output_buffer(delay_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.delay_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(delay_sptr self, int i) -> long"""
        return _blocks_swig0.delay_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(delay_sptr self, long min_output_buffer)
        set_min_output_buffer(delay_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.delay_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(delay_sptr self) -> float"""
        return _blocks_swig0.delay_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(delay_sptr self) -> float"""
        return _blocks_swig0.delay_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(delay_sptr self) -> float"""
        return _blocks_swig0.delay_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(delay_sptr self) -> float"""
        return _blocks_swig0.delay_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(delay_sptr self) -> float"""
        return _blocks_swig0.delay_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(delay_sptr self) -> float"""
        return _blocks_swig0.delay_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(delay_sptr self, int which) -> float
        pc_input_buffers_full(delay_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.delay_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(delay_sptr self, int which) -> float
        pc_input_buffers_full_avg(delay_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.delay_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(delay_sptr self, int which) -> float
        pc_input_buffers_full_var(delay_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.delay_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(delay_sptr self, int which) -> float
        pc_output_buffers_full(delay_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.delay_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(delay_sptr self, int which) -> float
        pc_output_buffers_full_avg(delay_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.delay_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(delay_sptr self, int which) -> float
        pc_output_buffers_full_var(delay_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.delay_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(delay_sptr self) -> float"""
        return _blocks_swig0.delay_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(delay_sptr self) -> float"""
        return _blocks_swig0.delay_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(delay_sptr self) -> float"""
        return _blocks_swig0.delay_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(delay_sptr self) -> float"""
        return _blocks_swig0.delay_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(delay_sptr self) -> float"""
        return _blocks_swig0.delay_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(delay_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.delay_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(delay_sptr self)"""
        return _blocks_swig0.delay_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(delay_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.delay_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(delay_sptr self) -> int"""
        return _blocks_swig0.delay_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(delay_sptr self) -> int"""
        return _blocks_swig0.delay_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(delay_sptr self, int priority) -> int"""
        return _blocks_swig0.delay_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(delay_sptr self) -> std::string"""
        return _blocks_swig0.delay_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(delay_sptr self) -> std::string"""
        return _blocks_swig0.delay_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(delay_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.delay_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(delay_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.delay_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(delay_sptr self) -> long"""
        return _blocks_swig0.delay_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(delay_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.delay_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(delay_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.delay_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(delay_sptr self) -> std::string"""
        return _blocks_swig0.delay_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(delay_sptr self, std::string name)"""
        return _blocks_swig0.delay_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(delay_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig0.delay_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(delay_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig0.delay_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(delay_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig0.delay_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(delay_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig0.delay_sptr_message_subscribers(self, which_port)

# Register delay_sptr in _blocks_swig0:
_blocks_swig0.delay_sptr_swigregister(delay_sptr)


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

class endian_swap_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::endian_swap > 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__(endian_swap_sptr self) -> endian_swap_sptr
        __init__(endian_swap_sptr self, endian_swap p) -> endian_swap_sptr
        """
        _blocks_swig0.endian_swap_sptr_swiginit(self, _blocks_swig0.new_endian_swap_sptr(*args))

    def __deref__(self) -> "gr::blocks::endian_swap *":
        r"""__deref__(endian_swap_sptr self) -> endian_swap"""
        return _blocks_swig0.endian_swap_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig0.delete_endian_swap_sptr

    def make(self, item_size_bytes: "size_t"=1) -> "gr::blocks::endian_swap::sptr":
        r"""make(endian_swap_sptr self, size_t item_size_bytes=1) -> endian_swap_sptr"""
        return _blocks_swig0.endian_swap_sptr_make(self, item_size_bytes)

    def history(self) -> "unsigned int":
        r"""history(endian_swap_sptr self) -> unsigned int"""
        return _blocks_swig0.endian_swap_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(endian_swap_sptr self, int which, int delay)
        declare_sample_delay(endian_swap_sptr self, unsigned int delay)
        """
        return _blocks_swig0.endian_swap_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(endian_swap_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.endian_swap_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(endian_swap_sptr self, int multiple)"""
        return _blocks_swig0.endian_swap_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(endian_swap_sptr self) -> int"""
        return _blocks_swig0.endian_swap_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(endian_swap_sptr self) -> double"""
        return _blocks_swig0.endian_swap_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(endian_swap_sptr self) -> uint64_t"""
        return _blocks_swig0.endian_swap_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(endian_swap_sptr self) -> uint64_t"""
        return _blocks_swig0.endian_swap_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(endian_swap_sptr self) -> bool"""
        return _blocks_swig0.endian_swap_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(endian_swap_sptr self) -> bool"""
        return _blocks_swig0.endian_swap_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(endian_swap_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.endian_swap_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(endian_swap_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.endian_swap_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(endian_swap_sptr self, std::string level)"""
        return _blocks_swig0.endian_swap_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(endian_swap_sptr self) -> std::string"""
        return _blocks_swig0.endian_swap_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(endian_swap_sptr self) -> int"""
        return _blocks_swig0.endian_swap_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(endian_swap_sptr self, int m)"""
        return _blocks_swig0.endian_swap_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(endian_swap_sptr self)"""
        return _blocks_swig0.endian_swap_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(endian_swap_sptr self) -> bool"""
        return _blocks_swig0.endian_swap_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(endian_swap_sptr self, int m)"""
        return _blocks_swig0.endian_swap_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(endian_swap_sptr self) -> int"""
        return _blocks_swig0.endian_swap_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(endian_swap_sptr self, int i) -> long"""
        return _blocks_swig0.endian_swap_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(endian_swap_sptr self, long max_output_buffer)
        set_max_output_buffer(endian_swap_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.endian_swap_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(endian_swap_sptr self, int i) -> long"""
        return _blocks_swig0.endian_swap_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(endian_swap_sptr self, long min_output_buffer)
        set_min_output_buffer(endian_swap_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.endian_swap_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(endian_swap_sptr self) -> float"""
        return _blocks_swig0.endian_swap_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(endian_swap_sptr self) -> float"""
        return _blocks_swig0.endian_swap_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(endian_swap_sptr self) -> float"""
        return _blocks_swig0.endian_swap_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(endian_swap_sptr self) -> float"""
        return _blocks_swig0.endian_swap_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(endian_swap_sptr self) -> float"""
        return _blocks_swig0.endian_swap_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(endian_swap_sptr self) -> float"""
        return _blocks_swig0.endian_swap_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(endian_swap_sptr self, int which) -> float
        pc_input_buffers_full(endian_swap_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.endian_swap_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(endian_swap_sptr self, int which) -> float
        pc_input_buffers_full_avg(endian_swap_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.endian_swap_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(endian_swap_sptr self, int which) -> float
        pc_input_buffers_full_var(endian_swap_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.endian_swap_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(endian_swap_sptr self, int which) -> float
        pc_output_buffers_full(endian_swap_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.endian_swap_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(endian_swap_sptr self, int which) -> float
        pc_output_buffers_full_avg(endian_swap_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.endian_swap_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(endian_swap_sptr self, int which) -> float
        pc_output_buffers_full_var(endian_swap_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.endian_swap_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(endian_swap_sptr self) -> float"""
        return _blocks_swig0.endian_swap_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(endian_swap_sptr self) -> float"""
        return _blocks_swig0.endian_swap_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(endian_swap_sptr self) -> float"""
        return _blocks_swig0.endian_swap_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(endian_swap_sptr self) -> float"""
        return _blocks_swig0.endian_swap_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(endian_swap_sptr self) -> float"""
        return _blocks_swig0.endian_swap_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(endian_swap_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.endian_swap_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(endian_swap_sptr self)"""
        return _blocks_swig0.endian_swap_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(endian_swap_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.endian_swap_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(endian_swap_sptr self) -> int"""
        return _blocks_swig0.endian_swap_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(endian_swap_sptr self) -> int"""
        return _blocks_swig0.endian_swap_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(endian_swap_sptr self, int priority) -> int"""
        return _blocks_swig0.endian_swap_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(endian_swap_sptr self) -> std::string"""
        return _blocks_swig0.endian_swap_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(endian_swap_sptr self) -> std::string"""
        return _blocks_swig0.endian_swap_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(endian_swap_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.endian_swap_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(endian_swap_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.endian_swap_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(endian_swap_sptr self) -> long"""
        return _blocks_swig0.endian_swap_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(endian_swap_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.endian_swap_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(endian_swap_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.endian_swap_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(endian_swap_sptr self) -> std::string"""
        return _blocks_swig0.endian_swap_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(endian_swap_sptr self, std::string name)"""
        return _blocks_swig0.endian_swap_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(endian_swap_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig0.endian_swap_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(endian_swap_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig0.endian_swap_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(endian_swap_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig0.endian_swap_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(endian_swap_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig0.endian_swap_sptr_message_subscribers(self, which_port)

# Register endian_swap_sptr in _blocks_swig0:
_blocks_swig0.endian_swap_sptr_swigregister(endian_swap_sptr)


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

class file_descriptor_sink_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::file_descriptor_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__(file_descriptor_sink_sptr self) -> file_descriptor_sink_sptr
        __init__(file_descriptor_sink_sptr self, file_descriptor_sink p) -> file_descriptor_sink_sptr
        """
        _blocks_swig0.file_descriptor_sink_sptr_swiginit(self, _blocks_swig0.new_file_descriptor_sink_sptr(*args))

    def __deref__(self) -> "gr::blocks::file_descriptor_sink *":
        r"""__deref__(file_descriptor_sink_sptr self) -> file_descriptor_sink"""
        return _blocks_swig0.file_descriptor_sink_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig0.delete_file_descriptor_sink_sptr

    def make(self, itemsize: "size_t", fd: "int") -> "gr::blocks::file_descriptor_sink::sptr":
        r"""make(file_descriptor_sink_sptr self, size_t itemsize, int fd) -> file_descriptor_sink_sptr"""
        return _blocks_swig0.file_descriptor_sink_sptr_make(self, itemsize, fd)

    def history(self) -> "unsigned int":
        r"""history(file_descriptor_sink_sptr self) -> unsigned int"""
        return _blocks_swig0.file_descriptor_sink_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(file_descriptor_sink_sptr self, int which, int delay)
        declare_sample_delay(file_descriptor_sink_sptr self, unsigned int delay)
        """
        return _blocks_swig0.file_descriptor_sink_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(file_descriptor_sink_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.file_descriptor_sink_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(file_descriptor_sink_sptr self, int multiple)"""
        return _blocks_swig0.file_descriptor_sink_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(file_descriptor_sink_sptr self) -> int"""
        return _blocks_swig0.file_descriptor_sink_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(file_descriptor_sink_sptr self) -> double"""
        return _blocks_swig0.file_descriptor_sink_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(file_descriptor_sink_sptr self) -> uint64_t"""
        return _blocks_swig0.file_descriptor_sink_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(file_descriptor_sink_sptr self) -> uint64_t"""
        return _blocks_swig0.file_descriptor_sink_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(file_descriptor_sink_sptr self) -> bool"""
        return _blocks_swig0.file_descriptor_sink_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(file_descriptor_sink_sptr self) -> bool"""
        return _blocks_swig0.file_descriptor_sink_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(file_descriptor_sink_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.file_descriptor_sink_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(file_descriptor_sink_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.file_descriptor_sink_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(file_descriptor_sink_sptr self, std::string level)"""
        return _blocks_swig0.file_descriptor_sink_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(file_descriptor_sink_sptr self) -> std::string"""
        return _blocks_swig0.file_descriptor_sink_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(file_descriptor_sink_sptr self) -> int"""
        return _blocks_swig0.file_descriptor_sink_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(file_descriptor_sink_sptr self, int m)"""
        return _blocks_swig0.file_descriptor_sink_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(file_descriptor_sink_sptr self)"""
        return _blocks_swig0.file_descriptor_sink_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(file_descriptor_sink_sptr self) -> bool"""
        return _blocks_swig0.file_descriptor_sink_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(file_descriptor_sink_sptr self, int m)"""
        return _blocks_swig0.file_descriptor_sink_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(file_descriptor_sink_sptr self) -> int"""
        return _blocks_swig0.file_descriptor_sink_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(file_descriptor_sink_sptr self, int i) -> long"""
        return _blocks_swig0.file_descriptor_sink_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(file_descriptor_sink_sptr self, long max_output_buffer)
        set_max_output_buffer(file_descriptor_sink_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.file_descriptor_sink_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(file_descriptor_sink_sptr self, int i) -> long"""
        return _blocks_swig0.file_descriptor_sink_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(file_descriptor_sink_sptr self, long min_output_buffer)
        set_min_output_buffer(file_descriptor_sink_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.file_descriptor_sink_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(file_descriptor_sink_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_sink_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(file_descriptor_sink_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_sink_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(file_descriptor_sink_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_sink_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(file_descriptor_sink_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_sink_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(file_descriptor_sink_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_sink_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(file_descriptor_sink_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_sink_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(file_descriptor_sink_sptr self, int which) -> float
        pc_input_buffers_full(file_descriptor_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_descriptor_sink_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(file_descriptor_sink_sptr self, int which) -> float
        pc_input_buffers_full_avg(file_descriptor_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_descriptor_sink_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(file_descriptor_sink_sptr self, int which) -> float
        pc_input_buffers_full_var(file_descriptor_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_descriptor_sink_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(file_descriptor_sink_sptr self, int which) -> float
        pc_output_buffers_full(file_descriptor_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_descriptor_sink_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(file_descriptor_sink_sptr self, int which) -> float
        pc_output_buffers_full_avg(file_descriptor_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_descriptor_sink_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(file_descriptor_sink_sptr self, int which) -> float
        pc_output_buffers_full_var(file_descriptor_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_descriptor_sink_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(file_descriptor_sink_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_sink_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(file_descriptor_sink_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_sink_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(file_descriptor_sink_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_sink_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(file_descriptor_sink_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_sink_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(file_descriptor_sink_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_sink_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(file_descriptor_sink_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.file_descriptor_sink_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(file_descriptor_sink_sptr self)"""
        return _blocks_swig0.file_descriptor_sink_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(file_descriptor_sink_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.file_descriptor_sink_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(file_descriptor_sink_sptr self) -> int"""
        return _blocks_swig0.file_descriptor_sink_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(file_descriptor_sink_sptr self) -> int"""
        return _blocks_swig0.file_descriptor_sink_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(file_descriptor_sink_sptr self, int priority) -> int"""
        return _blocks_swig0.file_descriptor_sink_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(file_descriptor_sink_sptr self) -> std::string"""
        return _blocks_swig0.file_descriptor_sink_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(file_descriptor_sink_sptr self) -> std::string"""
        return _blocks_swig0.file_descriptor_sink_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(file_descriptor_sink_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.file_descriptor_sink_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(file_descriptor_sink_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.file_descriptor_sink_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(file_descriptor_sink_sptr self) -> long"""
        return _blocks_swig0.file_descriptor_sink_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(file_descriptor_sink_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.file_descriptor_sink_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(file_descriptor_sink_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.file_descriptor_sink_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(file_descriptor_sink_sptr self) -> std::string"""
        return _blocks_swig0.file_descriptor_sink_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(file_descriptor_sink_sptr self, std::string name)"""
        return _blocks_swig0.file_descriptor_sink_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(file_descriptor_sink_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig0.file_descriptor_sink_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(file_descriptor_sink_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig0.file_descriptor_sink_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(file_descriptor_sink_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig0.file_descriptor_sink_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(file_descriptor_sink_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig0.file_descriptor_sink_sptr_message_subscribers(self, which_port)

# Register file_descriptor_sink_sptr in _blocks_swig0:
_blocks_swig0.file_descriptor_sink_sptr_swigregister(file_descriptor_sink_sptr)


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

class file_descriptor_source_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::file_descriptor_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__(file_descriptor_source_sptr self) -> file_descriptor_source_sptr
        __init__(file_descriptor_source_sptr self, file_descriptor_source p) -> file_descriptor_source_sptr
        """
        _blocks_swig0.file_descriptor_source_sptr_swiginit(self, _blocks_swig0.new_file_descriptor_source_sptr(*args))

    def __deref__(self) -> "gr::blocks::file_descriptor_source *":
        r"""__deref__(file_descriptor_source_sptr self) -> file_descriptor_source"""
        return _blocks_swig0.file_descriptor_source_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig0.delete_file_descriptor_source_sptr

    def make(self, itemsize: "size_t", fd: "int", repeat: "bool"=False) -> "gr::blocks::file_descriptor_source::sptr":
        r"""make(file_descriptor_source_sptr self, size_t itemsize, int fd, bool repeat=False) -> file_descriptor_source_sptr"""
        return _blocks_swig0.file_descriptor_source_sptr_make(self, itemsize, fd, repeat)

    def history(self) -> "unsigned int":
        r"""history(file_descriptor_source_sptr self) -> unsigned int"""
        return _blocks_swig0.file_descriptor_source_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(file_descriptor_source_sptr self, int which, int delay)
        declare_sample_delay(file_descriptor_source_sptr self, unsigned int delay)
        """
        return _blocks_swig0.file_descriptor_source_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(file_descriptor_source_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.file_descriptor_source_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(file_descriptor_source_sptr self, int multiple)"""
        return _blocks_swig0.file_descriptor_source_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(file_descriptor_source_sptr self) -> int"""
        return _blocks_swig0.file_descriptor_source_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(file_descriptor_source_sptr self) -> double"""
        return _blocks_swig0.file_descriptor_source_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(file_descriptor_source_sptr self) -> uint64_t"""
        return _blocks_swig0.file_descriptor_source_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(file_descriptor_source_sptr self) -> uint64_t"""
        return _blocks_swig0.file_descriptor_source_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(file_descriptor_source_sptr self) -> bool"""
        return _blocks_swig0.file_descriptor_source_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(file_descriptor_source_sptr self) -> bool"""
        return _blocks_swig0.file_descriptor_source_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(file_descriptor_source_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.file_descriptor_source_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(file_descriptor_source_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.file_descriptor_source_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(file_descriptor_source_sptr self, std::string level)"""
        return _blocks_swig0.file_descriptor_source_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(file_descriptor_source_sptr self) -> std::string"""
        return _blocks_swig0.file_descriptor_source_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(file_descriptor_source_sptr self) -> int"""
        return _blocks_swig0.file_descriptor_source_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(file_descriptor_source_sptr self, int m)"""
        return _blocks_swig0.file_descriptor_source_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(file_descriptor_source_sptr self)"""
        return _blocks_swig0.file_descriptor_source_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(file_descriptor_source_sptr self) -> bool"""
        return _blocks_swig0.file_descriptor_source_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(file_descriptor_source_sptr self, int m)"""
        return _blocks_swig0.file_descriptor_source_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(file_descriptor_source_sptr self) -> int"""
        return _blocks_swig0.file_descriptor_source_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(file_descriptor_source_sptr self, int i) -> long"""
        return _blocks_swig0.file_descriptor_source_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(file_descriptor_source_sptr self, long max_output_buffer)
        set_max_output_buffer(file_descriptor_source_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.file_descriptor_source_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(file_descriptor_source_sptr self, int i) -> long"""
        return _blocks_swig0.file_descriptor_source_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(file_descriptor_source_sptr self, long min_output_buffer)
        set_min_output_buffer(file_descriptor_source_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.file_descriptor_source_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(file_descriptor_source_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_source_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(file_descriptor_source_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_source_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(file_descriptor_source_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_source_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(file_descriptor_source_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_source_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(file_descriptor_source_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_source_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(file_descriptor_source_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_source_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(file_descriptor_source_sptr self, int which) -> float
        pc_input_buffers_full(file_descriptor_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_descriptor_source_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(file_descriptor_source_sptr self, int which) -> float
        pc_input_buffers_full_avg(file_descriptor_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_descriptor_source_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(file_descriptor_source_sptr self, int which) -> float
        pc_input_buffers_full_var(file_descriptor_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_descriptor_source_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(file_descriptor_source_sptr self, int which) -> float
        pc_output_buffers_full(file_descriptor_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_descriptor_source_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(file_descriptor_source_sptr self, int which) -> float
        pc_output_buffers_full_avg(file_descriptor_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_descriptor_source_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(file_descriptor_source_sptr self, int which) -> float
        pc_output_buffers_full_var(file_descriptor_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_descriptor_source_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(file_descriptor_source_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_source_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(file_descriptor_source_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_source_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(file_descriptor_source_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_source_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(file_descriptor_source_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_source_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(file_descriptor_source_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_source_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(file_descriptor_source_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.file_descriptor_source_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(file_descriptor_source_sptr self)"""
        return _blocks_swig0.file_descriptor_source_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(file_descriptor_source_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.file_descriptor_source_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(file_descriptor_source_sptr self) -> int"""
        return _blocks_swig0.file_descriptor_source_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(file_descriptor_source_sptr self) -> int"""
        return _blocks_swig0.file_descriptor_source_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(file_descriptor_source_sptr self, int priority) -> int"""
        return _blocks_swig0.file_descriptor_source_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(file_descriptor_source_sptr self) -> std::string"""
        return _blocks_swig0.file_descriptor_source_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(file_descriptor_source_sptr self) -> std::string"""
        return _blocks_swig0.file_descriptor_source_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(file_descriptor_source_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.file_descriptor_source_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(file_descriptor_source_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.file_descriptor_source_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(file_descriptor_source_sptr self) -> long"""
        return _blocks_swig0.file_descriptor_source_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(file_descriptor_source_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.file_descriptor_source_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(file_descriptor_source_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.file_descriptor_source_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(file_descriptor_source_sptr self) -> std::string"""
        return _blocks_swig0.file_descriptor_source_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(file_descriptor_source_sptr self, std::string name)"""
        return _blocks_swig0.file_descriptor_source_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(file_descriptor_source_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig0.file_descriptor_source_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(file_descriptor_source_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig0.file_descriptor_source_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(file_descriptor_source_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig0.file_descriptor_source_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(file_descriptor_source_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig0.file_descriptor_source_sptr_message_subscribers(self, which_port)

# Register file_descriptor_source_sptr in _blocks_swig0:
_blocks_swig0.file_descriptor_source_sptr_swigregister(file_descriptor_source_sptr)


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

class file_sink_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::file_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__(file_sink_sptr self) -> file_sink_sptr
        __init__(file_sink_sptr self, file_sink p) -> file_sink_sptr
        """
        _blocks_swig0.file_sink_sptr_swiginit(self, _blocks_swig0.new_file_sink_sptr(*args))

    def __deref__(self) -> "gr::blocks::file_sink *":
        r"""__deref__(file_sink_sptr self) -> file_sink"""
        return _blocks_swig0.file_sink_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig0.delete_file_sink_sptr

    def make(self, itemsize: "size_t", filename: "char const *", append: "bool"=False) -> "gr::blocks::file_sink::sptr":
        r"""make(file_sink_sptr self, size_t itemsize, char const * filename, bool append=False) -> file_sink_sptr"""
        return _blocks_swig0.file_sink_sptr_make(self, itemsize, filename, append)

    def history(self) -> "unsigned int":
        r"""history(file_sink_sptr self) -> unsigned int"""
        return _blocks_swig0.file_sink_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(file_sink_sptr self, int which, int delay)
        declare_sample_delay(file_sink_sptr self, unsigned int delay)
        """
        return _blocks_swig0.file_sink_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(file_sink_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.file_sink_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(file_sink_sptr self, int multiple)"""
        return _blocks_swig0.file_sink_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(file_sink_sptr self) -> int"""
        return _blocks_swig0.file_sink_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(file_sink_sptr self) -> double"""
        return _blocks_swig0.file_sink_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(file_sink_sptr self) -> uint64_t"""
        return _blocks_swig0.file_sink_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(file_sink_sptr self) -> uint64_t"""
        return _blocks_swig0.file_sink_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(file_sink_sptr self) -> bool"""
        return _blocks_swig0.file_sink_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(file_sink_sptr self) -> bool"""
        return _blocks_swig0.file_sink_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(file_sink_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.file_sink_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(file_sink_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.file_sink_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(file_sink_sptr self, std::string level)"""
        return _blocks_swig0.file_sink_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(file_sink_sptr self) -> std::string"""
        return _blocks_swig0.file_sink_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(file_sink_sptr self) -> int"""
        return _blocks_swig0.file_sink_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(file_sink_sptr self, int m)"""
        return _blocks_swig0.file_sink_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(file_sink_sptr self)"""
        return _blocks_swig0.file_sink_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(file_sink_sptr self) -> bool"""
        return _blocks_swig0.file_sink_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(file_sink_sptr self, int m)"""
        return _blocks_swig0.file_sink_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(file_sink_sptr self) -> int"""
        return _blocks_swig0.file_sink_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(file_sink_sptr self, int i) -> long"""
        return _blocks_swig0.file_sink_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(file_sink_sptr self, long max_output_buffer)
        set_max_output_buffer(file_sink_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.file_sink_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(file_sink_sptr self, int i) -> long"""
        return _blocks_swig0.file_sink_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(file_sink_sptr self, long min_output_buffer)
        set_min_output_buffer(file_sink_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.file_sink_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(file_sink_sptr self) -> float"""
        return _blocks_swig0.file_sink_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(file_sink_sptr self) -> float"""
        return _blocks_swig0.file_sink_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(file_sink_sptr self) -> float"""
        return _blocks_swig0.file_sink_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(file_sink_sptr self) -> float"""
        return _blocks_swig0.file_sink_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(file_sink_sptr self) -> float"""
        return _blocks_swig0.file_sink_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(file_sink_sptr self) -> float"""
        return _blocks_swig0.file_sink_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(file_sink_sptr self, int which) -> float
        pc_input_buffers_full(file_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_sink_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(file_sink_sptr self, int which) -> float
        pc_input_buffers_full_avg(file_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_sink_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(file_sink_sptr self, int which) -> float
        pc_input_buffers_full_var(file_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_sink_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(file_sink_sptr self, int which) -> float
        pc_output_buffers_full(file_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_sink_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(file_sink_sptr self, int which) -> float
        pc_output_buffers_full_avg(file_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_sink_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(file_sink_sptr self, int which) -> float
        pc_output_buffers_full_var(file_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_sink_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(file_sink_sptr self) -> float"""
        return _blocks_swig0.file_sink_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(file_sink_sptr self) -> float"""
        return _blocks_swig0.file_sink_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(file_sink_sptr self) -> float"""
        return _blocks_swig0.file_sink_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(file_sink_sptr self) -> float"""
        return _blocks_swig0.file_sink_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(file_sink_sptr self) -> float"""
        return _blocks_swig0.file_sink_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(file_sink_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.file_sink_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(file_sink_sptr self)"""
        return _blocks_swig0.file_sink_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(file_sink_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.file_sink_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(file_sink_sptr self) -> int"""
        return _blocks_swig0.file_sink_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(file_sink_sptr self) -> int"""
        return _blocks_swig0.file_sink_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(file_sink_sptr self, int priority) -> int"""
        return _blocks_swig0.file_sink_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(file_sink_sptr self) -> std::string"""
        return _blocks_swig0.file_sink_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(file_sink_sptr self) -> std::string"""
        return _blocks_swig0.file_sink_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(file_sink_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.file_sink_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(file_sink_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.file_sink_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(file_sink_sptr self) -> long"""
        return _blocks_swig0.file_sink_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(file_sink_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.file_sink_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(file_sink_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.file_sink_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(file_sink_sptr self) -> std::string"""
        return _blocks_swig0.file_sink_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(file_sink_sptr self, std::string name)"""
        return _blocks_swig0.file_sink_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(file_sink_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig0.file_sink_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(file_sink_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig0.file_sink_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(file_sink_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig0.file_sink_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(file_sink_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig0.file_sink_sptr_message_subscribers(self, which_port)

    def open(self, filename: "char const *") -> "bool":
        r"""open(file_sink_sptr self, char const * filename) -> bool"""
        return _blocks_swig0.file_sink_sptr_open(self, filename)

    def close(self) -> "void":
        r"""close(file_sink_sptr self)"""
        return _blocks_swig0.file_sink_sptr_close(self)

    def do_update(self) -> "void":
        r"""do_update(file_sink_sptr self)"""
        return _blocks_swig0.file_sink_sptr_do_update(self)

    def set_unbuffered(self, unbuffered: "bool") -> "void":
        r"""set_unbuffered(file_sink_sptr self, bool unbuffered)"""
        return _blocks_swig0.file_sink_sptr_set_unbuffered(self, unbuffered)

# Register file_sink_sptr in _blocks_swig0:
_blocks_swig0.file_sink_sptr_swigregister(file_sink_sptr)


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

class file_source_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::file_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__(file_source_sptr self) -> file_source_sptr
        __init__(file_source_sptr self, file_source p) -> file_source_sptr
        """
        _blocks_swig0.file_source_sptr_swiginit(self, _blocks_swig0.new_file_source_sptr(*args))

    def __deref__(self) -> "gr::blocks::file_source *":
        r"""__deref__(file_source_sptr self) -> file_source"""
        return _blocks_swig0.file_source_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig0.delete_file_source_sptr

    def make(self, itemsize: "size_t", filename: "char const *", repeat: "bool"=False, offset: "uint64_t"=0, len: "uint64_t"=0) -> "gr::blocks::file_source::sptr":
        r"""make(file_source_sptr self, size_t itemsize, char const * filename, bool repeat=False, uint64_t offset=0, uint64_t len=0) -> file_source_sptr"""
        return _blocks_swig0.file_source_sptr_make(self, itemsize, filename, repeat, offset, len)

    def seek(self, seek_point: "int64_t", whence: "int") -> "bool":
        r"""seek(file_source_sptr self, int64_t seek_point, int whence) -> bool"""
        return _blocks_swig0.file_source_sptr_seek(self, seek_point, whence)

    def open(self, filename: "char const *", repeat: "bool", offset: "uint64_t"=0, len: "uint64_t"=0) -> "void":
        r"""open(file_source_sptr self, char const * filename, bool repeat, uint64_t offset=0, uint64_t len=0)"""
        return _blocks_swig0.file_source_sptr_open(self, filename, repeat, offset, len)

    def close(self) -> "void":
        r"""close(file_source_sptr self)"""
        return _blocks_swig0.file_source_sptr_close(self)

    def set_begin_tag(self, val: "swig_pmt_ptr") -> "void":
        r"""set_begin_tag(file_source_sptr self, swig_pmt_ptr val)"""
        return _blocks_swig0.file_source_sptr_set_begin_tag(self, val)

    def history(self) -> "unsigned int":
        r"""history(file_source_sptr self) -> unsigned int"""
        return _blocks_swig0.file_source_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(file_source_sptr self, int which, int delay)
        declare_sample_delay(file_source_sptr self, unsigned int delay)
        """
        return _blocks_swig0.file_source_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(file_source_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.file_source_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(file_source_sptr self, int multiple)"""
        return _blocks_swig0.file_source_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(file_source_sptr self) -> int"""
        return _blocks_swig0.file_source_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(file_source_sptr self) -> double"""
        return _blocks_swig0.file_source_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(file_source_sptr self) -> uint64_t"""
        return _blocks_swig0.file_source_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(file_source_sptr self) -> uint64_t"""
        return _blocks_swig0.file_source_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(file_source_sptr self) -> bool"""
        return _blocks_swig0.file_source_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(file_source_sptr self) -> bool"""
        return _blocks_swig0.file_source_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(file_source_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.file_source_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(file_source_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.file_source_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(file_source_sptr self, std::string level)"""
        return _blocks_swig0.file_source_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(file_source_sptr self) -> std::string"""
        return _blocks_swig0.file_source_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(file_source_sptr self) -> int"""
        return _blocks_swig0.file_source_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(file_source_sptr self, int m)"""
        return _blocks_swig0.file_source_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(file_source_sptr self)"""
        return _blocks_swig0.file_source_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(file_source_sptr self) -> bool"""
        return _blocks_swig0.file_source_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(file_source_sptr self, int m)"""
        return _blocks_swig0.file_source_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(file_source_sptr self) -> int"""
        return _blocks_swig0.file_source_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(file_source_sptr self, int i) -> long"""
        return _blocks_swig0.file_source_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(file_source_sptr self, long max_output_buffer)
        set_max_output_buffer(file_source_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.file_source_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(file_source_sptr self, int i) -> long"""
        return _blocks_swig0.file_source_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(file_source_sptr self, long min_output_buffer)
        set_min_output_buffer(file_source_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.file_source_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(file_source_sptr self) -> float"""
        return _blocks_swig0.file_source_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(file_source_sptr self) -> float"""
        return _blocks_swig0.file_source_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(file_source_sptr self) -> float"""
        return _blocks_swig0.file_source_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(file_source_sptr self) -> float"""
        return _blocks_swig0.file_source_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(file_source_sptr self) -> float"""
        return _blocks_swig0.file_source_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(file_source_sptr self) -> float"""
        return _blocks_swig0.file_source_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(file_source_sptr self, int which) -> float
        pc_input_buffers_full(file_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_source_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(file_source_sptr self, int which) -> float
        pc_input_buffers_full_avg(file_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_source_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(file_source_sptr self, int which) -> float
        pc_input_buffers_full_var(file_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_source_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(file_source_sptr self, int which) -> float
        pc_output_buffers_full(file_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_source_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(file_source_sptr self, int which) -> float
        pc_output_buffers_full_avg(file_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_source_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(file_source_sptr self, int which) -> float
        pc_output_buffers_full_var(file_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_source_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(file_source_sptr self) -> float"""
        return _blocks_swig0.file_source_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(file_source_sptr self) -> float"""
        return _blocks_swig0.file_source_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(file_source_sptr self) -> float"""
        return _blocks_swig0.file_source_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(file_source_sptr self) -> float"""
        return _blocks_swig0.file_source_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(file_source_sptr self) -> float"""
        return _blocks_swig0.file_source_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(file_source_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.file_source_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(file_source_sptr self)"""
        return _blocks_swig0.file_source_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(file_source_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.file_source_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(file_source_sptr self) -> int"""
        return _blocks_swig0.file_source_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(file_source_sptr self) -> int"""
        return _blocks_swig0.file_source_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(file_source_sptr self, int priority) -> int"""
        return _blocks_swig0.file_source_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(file_source_sptr self) -> std::string"""
        return _blocks_swig0.file_source_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(file_source_sptr self) -> std::string"""
        return _blocks_swig0.file_source_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(file_source_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.file_source_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(file_source_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.file_source_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(file_source_sptr self) -> long"""
        return _blocks_swig0.file_source_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(file_source_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.file_source_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(file_source_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.file_source_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(file_source_sptr self) -> std::string"""
        return _blocks_swig0.file_source_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(file_source_sptr self, std::string name)"""
        return _blocks_swig0.file_source_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(file_source_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig0.file_source_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(file_source_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig0.file_source_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(file_source_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig0.file_source_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(file_source_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig0.file_source_sptr_message_subscribers(self, which_port)

# Register file_source_sptr in _blocks_swig0:
_blocks_swig0.file_source_sptr_swigregister(file_source_sptr)


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

class file_meta_sink_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::file_meta_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__(file_meta_sink_sptr self) -> file_meta_sink_sptr
        __init__(file_meta_sink_sptr self, file_meta_sink p) -> file_meta_sink_sptr
        """
        _blocks_swig0.file_meta_sink_sptr_swiginit(self, _blocks_swig0.new_file_meta_sink_sptr(*args))

    def __deref__(self) -> "gr::blocks::file_meta_sink *":
        r"""__deref__(file_meta_sink_sptr self) -> file_meta_sink"""
        return _blocks_swig0.file_meta_sink_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig0.delete_file_meta_sink_sptr

    def make(self, *args, **kwargs) -> "gr::blocks::file_meta_sink::sptr":
        r"""make(file_meta_sink_sptr self, size_t itemsize, std::string const & filename, double samp_rate=1, double relative_rate=1, gr::blocks::gr_file_types type=GR_FILE_FLOAT, bool complex=True, size_t max_segment_size=1000000, swig_pmt_ptr extra_dict=pmt::make_dict(), bool detached_header=False) -> file_meta_sink_sptr"""
        return _blocks_swig0.file_meta_sink_sptr_make(self, *args, **kwargs)

    def open(self, filename: "std::string const &") -> "bool":
        r"""open(file_meta_sink_sptr self, std::string const & filename) -> bool"""
        return _blocks_swig0.file_meta_sink_sptr_open(self, filename)

    def close(self) -> "void":
        r"""close(file_meta_sink_sptr self)"""
        return _blocks_swig0.file_meta_sink_sptr_close(self)

    def do_update(self) -> "void":
        r"""do_update(file_meta_sink_sptr self)"""
        return _blocks_swig0.file_meta_sink_sptr_do_update(self)

    def set_unbuffered(self, unbuffered: "bool") -> "void":
        r"""set_unbuffered(file_meta_sink_sptr self, bool unbuffered)"""
        return _blocks_swig0.file_meta_sink_sptr_set_unbuffered(self, unbuffered)

    def history(self) -> "unsigned int":
        r"""history(file_meta_sink_sptr self) -> unsigned int"""
        return _blocks_swig0.file_meta_sink_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(file_meta_sink_sptr self, int which, int delay)
        declare_sample_delay(file_meta_sink_sptr self, unsigned int delay)
        """
        return _blocks_swig0.file_meta_sink_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(file_meta_sink_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.file_meta_sink_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(file_meta_sink_sptr self, int multiple)"""
        return _blocks_swig0.file_meta_sink_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(file_meta_sink_sptr self) -> int"""
        return _blocks_swig0.file_meta_sink_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(file_meta_sink_sptr self) -> double"""
        return _blocks_swig0.file_meta_sink_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(file_meta_sink_sptr self) -> uint64_t"""
        return _blocks_swig0.file_meta_sink_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(file_meta_sink_sptr self) -> uint64_t"""
        return _blocks_swig0.file_meta_sink_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(file_meta_sink_sptr self) -> bool"""
        return _blocks_swig0.file_meta_sink_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(file_meta_sink_sptr self) -> bool"""
        return _blocks_swig0.file_meta_sink_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(file_meta_sink_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.file_meta_sink_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(file_meta_sink_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.file_meta_sink_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(file_meta_sink_sptr self, std::string level)"""
        return _blocks_swig0.file_meta_sink_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(file_meta_sink_sptr self) -> std::string"""
        return _blocks_swig0.file_meta_sink_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(file_meta_sink_sptr self) -> int"""
        return _blocks_swig0.file_meta_sink_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(file_meta_sink_sptr self, int m)"""
        return _blocks_swig0.file_meta_sink_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(file_meta_sink_sptr self)"""
        return _blocks_swig0.file_meta_sink_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(file_meta_sink_sptr self) -> bool"""
        return _blocks_swig0.file_meta_sink_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(file_meta_sink_sptr self, int m)"""
        return _blocks_swig0.file_meta_sink_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(file_meta_sink_sptr self) -> int"""
        return _blocks_swig0.file_meta_sink_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(file_meta_sink_sptr self, int i) -> long"""
        return _blocks_swig0.file_meta_sink_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(file_meta_sink_sptr self, long max_output_buffer)
        set_max_output_buffer(file_meta_sink_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.file_meta_sink_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(file_meta_sink_sptr self, int i) -> long"""
        return _blocks_swig0.file_meta_sink_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(file_meta_sink_sptr self, long min_output_buffer)
        set_min_output_buffer(file_meta_sink_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.file_meta_sink_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(file_meta_sink_sptr self) -> float"""
        return _blocks_swig0.file_meta_sink_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(file_meta_sink_sptr self) -> float"""
        return _blocks_swig0.file_meta_sink_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(file_meta_sink_sptr self) -> float"""
        return _blocks_swig0.file_meta_sink_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(file_meta_sink_sptr self) -> float"""
        return _blocks_swig0.file_meta_sink_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(file_meta_sink_sptr self) -> float"""
        return _blocks_swig0.file_meta_sink_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(file_meta_sink_sptr self) -> float"""
        return _blocks_swig0.file_meta_sink_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(file_meta_sink_sptr self, int which) -> float
        pc_input_buffers_full(file_meta_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_meta_sink_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(file_meta_sink_sptr self, int which) -> float
        pc_input_buffers_full_avg(file_meta_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_meta_sink_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(file_meta_sink_sptr self, int which) -> float
        pc_input_buffers_full_var(file_meta_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_meta_sink_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(file_meta_sink_sptr self, int which) -> float
        pc_output_buffers_full(file_meta_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_meta_sink_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(file_meta_sink_sptr self, int which) -> float
        pc_output_buffers_full_avg(file_meta_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_meta_sink_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(file_meta_sink_sptr self, int which) -> float
        pc_output_buffers_full_var(file_meta_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_meta_sink_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(file_meta_sink_sptr self) -> float"""
        return _blocks_swig0.file_meta_sink_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(file_meta_sink_sptr self) -> float"""
        return _blocks_swig0.file_meta_sink_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(file_meta_sink_sptr self) -> float"""
        return _blocks_swig0.file_meta_sink_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(file_meta_sink_sptr self) -> float"""
        return _blocks_swig0.file_meta_sink_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(file_meta_sink_sptr self) -> float"""
        return _blocks_swig0.file_meta_sink_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(file_meta_sink_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.file_meta_sink_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(file_meta_sink_sptr self)"""
        return _blocks_swig0.file_meta_sink_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(file_meta_sink_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.file_meta_sink_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(file_meta_sink_sptr self) -> int"""
        return _blocks_swig0.file_meta_sink_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(file_meta_sink_sptr self) -> int"""
        return _blocks_swig0.file_meta_sink_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(file_meta_sink_sptr self, int priority) -> int"""
        return _blocks_swig0.file_meta_sink_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(file_meta_sink_sptr self) -> std::string"""
        return _blocks_swig0.file_meta_sink_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(file_meta_sink_sptr self) -> std::string"""
        return _blocks_swig0.file_meta_sink_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(file_meta_sink_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.file_meta_sink_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(file_meta_sink_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.file_meta_sink_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(file_meta_sink_sptr self) -> long"""
        return _blocks_swig0.file_meta_sink_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(file_meta_sink_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.file_meta_sink_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(file_meta_sink_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.file_meta_sink_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(file_meta_sink_sptr self) -> std::string"""
        return _blocks_swig0.file_meta_sink_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(file_meta_sink_sptr self, std::string name)"""
        return _blocks_swig0.file_meta_sink_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(file_meta_sink_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig0.file_meta_sink_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(file_meta_sink_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig0.file_meta_sink_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(file_meta_sink_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig0.file_meta_sink_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(file_meta_sink_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig0.file_meta_sink_sptr_message_subscribers(self, which_port)

# Register file_meta_sink_sptr in _blocks_swig0:
_blocks_swig0.file_meta_sink_sptr_swigregister(file_meta_sink_sptr)


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

class file_meta_source_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::file_meta_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__(file_meta_source_sptr self) -> file_meta_source_sptr
        __init__(file_meta_source_sptr self, file_meta_source p) -> file_meta_source_sptr
        """
        _blocks_swig0.file_meta_source_sptr_swiginit(self, _blocks_swig0.new_file_meta_source_sptr(*args))

    def __deref__(self) -> "gr::blocks::file_meta_source *":
        r"""__deref__(file_meta_source_sptr self) -> file_meta_source"""
        return _blocks_swig0.file_meta_source_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig0.delete_file_meta_source_sptr

    def make(self, *args, **kwargs) -> "gr::blocks::file_meta_source::sptr":
        r"""make(file_meta_source_sptr self, std::string const & filename, bool repeat=False, bool detached_header=False, std::string const & hdr_filename="") -> file_meta_source_sptr"""
        return _blocks_swig0.file_meta_source_sptr_make(self, *args, **kwargs)

    def open(self, *args, **kwargs) -> "bool":
        r"""open(file_meta_source_sptr self, std::string const & filename, std::string const & hdr_filename="") -> bool"""
        return _blocks_swig0.file_meta_source_sptr_open(self, *args, **kwargs)

    def close(self) -> "void":
        r"""close(file_meta_source_sptr self)"""
        return _blocks_swig0.file_meta_source_sptr_close(self)

    def do_update(self) -> "void":
        r"""do_update(file_meta_source_sptr self)"""
        return _blocks_swig0.file_meta_source_sptr_do_update(self)

    def history(self) -> "unsigned int":
        r"""history(file_meta_source_sptr self) -> unsigned int"""
        return _blocks_swig0.file_meta_source_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(file_meta_source_sptr self, int which, int delay)
        declare_sample_delay(file_meta_source_sptr self, unsigned int delay)
        """
        return _blocks_swig0.file_meta_source_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(file_meta_source_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.file_meta_source_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(file_meta_source_sptr self, int multiple)"""
        return _blocks_swig0.file_meta_source_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(file_meta_source_sptr self) -> int"""
        return _blocks_swig0.file_meta_source_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(file_meta_source_sptr self) -> double"""
        return _blocks_swig0.file_meta_source_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(file_meta_source_sptr self) -> uint64_t"""
        return _blocks_swig0.file_meta_source_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(file_meta_source_sptr self) -> uint64_t"""
        return _blocks_swig0.file_meta_source_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(file_meta_source_sptr self) -> bool"""
        return _blocks_swig0.file_meta_source_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(file_meta_source_sptr self) -> bool"""
        return _blocks_swig0.file_meta_source_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(file_meta_source_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.file_meta_source_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(file_meta_source_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.file_meta_source_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(file_meta_source_sptr self, std::string level)"""
        return _blocks_swig0.file_meta_source_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(file_meta_source_sptr self) -> std::string"""
        return _blocks_swig0.file_meta_source_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(file_meta_source_sptr self) -> int"""
        return _blocks_swig0.file_meta_source_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(file_meta_source_sptr self, int m)"""
        return _blocks_swig0.file_meta_source_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(file_meta_source_sptr self)"""
        return _blocks_swig0.file_meta_source_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(file_meta_source_sptr self) -> bool"""
        return _blocks_swig0.file_meta_source_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(file_meta_source_sptr self, int m)"""
        return _blocks_swig0.file_meta_source_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(file_meta_source_sptr self) -> int"""
        return _blocks_swig0.file_meta_source_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(file_meta_source_sptr self, int i) -> long"""
        return _blocks_swig0.file_meta_source_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(file_meta_source_sptr self, long max_output_buffer)
        set_max_output_buffer(file_meta_source_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.file_meta_source_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(file_meta_source_sptr self, int i) -> long"""
        return _blocks_swig0.file_meta_source_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(file_meta_source_sptr self, long min_output_buffer)
        set_min_output_buffer(file_meta_source_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.file_meta_source_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(file_meta_source_sptr self) -> float"""
        return _blocks_swig0.file_meta_source_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(file_meta_source_sptr self) -> float"""
        return _blocks_swig0.file_meta_source_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(file_meta_source_sptr self) -> float"""
        return _blocks_swig0.file_meta_source_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(file_meta_source_sptr self) -> float"""
        return _blocks_swig0.file_meta_source_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(file_meta_source_sptr self) -> float"""
        return _blocks_swig0.file_meta_source_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(file_meta_source_sptr self) -> float"""
        return _blocks_swig0.file_meta_source_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(file_meta_source_sptr self, int which) -> float
        pc_input_buffers_full(file_meta_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_meta_source_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(file_meta_source_sptr self, int which) -> float
        pc_input_buffers_full_avg(file_meta_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_meta_source_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(file_meta_source_sptr self, int which) -> float
        pc_input_buffers_full_var(file_meta_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_meta_source_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(file_meta_source_sptr self, int which) -> float
        pc_output_buffers_full(file_meta_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_meta_source_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(file_meta_source_sptr self, int which) -> float
        pc_output_buffers_full_avg(file_meta_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_meta_source_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(file_meta_source_sptr self, int which) -> float
        pc_output_buffers_full_var(file_meta_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_meta_source_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(file_meta_source_sptr self) -> float"""
        return _blocks_swig0.file_meta_source_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(file_meta_source_sptr self) -> float"""
        return _blocks_swig0.file_meta_source_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(file_meta_source_sptr self) -> float"""
        return _blocks_swig0.file_meta_source_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(file_meta_source_sptr self) -> float"""
        return _blocks_swig0.file_meta_source_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(file_meta_source_sptr self) -> float"""
        return _blocks_swig0.file_meta_source_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(file_meta_source_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.file_meta_source_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(file_meta_source_sptr self)"""
        return _blocks_swig0.file_meta_source_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(file_meta_source_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.file_meta_source_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(file_meta_source_sptr self) -> int"""
        return _blocks_swig0.file_meta_source_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(file_meta_source_sptr self) -> int"""
        return _blocks_swig0.file_meta_source_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(file_meta_source_sptr self, int priority) -> int"""
        return _blocks_swig0.file_meta_source_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(file_meta_source_sptr self) -> std::string"""
        return _blocks_swig0.file_meta_source_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(file_meta_source_sptr self) -> std::string"""
        return _blocks_swig0.file_meta_source_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(file_meta_source_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.file_meta_source_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(file_meta_source_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.file_meta_source_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(file_meta_source_sptr self) -> long"""
        return _blocks_swig0.file_meta_source_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(file_meta_source_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.file_meta_source_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(file_meta_source_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.file_meta_source_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(file_meta_source_sptr self) -> std::string"""
        return _blocks_swig0.file_meta_source_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(file_meta_source_sptr self, std::string name)"""
        return _blocks_swig0.file_meta_source_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(file_meta_source_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig0.file_meta_source_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(file_meta_source_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig0.file_meta_source_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(file_meta_source_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig0.file_meta_source_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(file_meta_source_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig0.file_meta_source_sptr_message_subscribers(self, which_port)

# Register file_meta_source_sptr in _blocks_swig0:
_blocks_swig0.file_meta_source_sptr_swigregister(file_meta_source_sptr)


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

class head_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::head > 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__(head_sptr self) -> head_sptr
        __init__(head_sptr self, head p) -> head_sptr
        """
        _blocks_swig0.head_sptr_swiginit(self, _blocks_swig0.new_head_sptr(*args))

    def __deref__(self) -> "gr::blocks::head *":
        r"""__deref__(head_sptr self) -> head"""
        return _blocks_swig0.head_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig0.delete_head_sptr

    def make(self, sizeof_stream_item: "size_t", nitems: "uint64_t") -> "gr::blocks::head::sptr":
        r"""make(head_sptr self, size_t sizeof_stream_item, uint64_t nitems) -> head_sptr"""
        return _blocks_swig0.head_sptr_make(self, sizeof_stream_item, nitems)

    def reset(self) -> "void":
        r"""reset(head_sptr self)"""
        return _blocks_swig0.head_sptr_reset(self)

    def set_length(self, nitems: "uint64_t") -> "void":
        r"""set_length(head_sptr self, uint64_t nitems)"""
        return _blocks_swig0.head_sptr_set_length(self, nitems)

    def history(self) -> "unsigned int":
        r"""history(head_sptr self) -> unsigned int"""
        return _blocks_swig0.head_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(head_sptr self, int which, int delay)
        declare_sample_delay(head_sptr self, unsigned int delay)
        """
        return _blocks_swig0.head_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(head_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.head_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(head_sptr self, int multiple)"""
        return _blocks_swig0.head_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(head_sptr self) -> int"""
        return _blocks_swig0.head_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(head_sptr self) -> double"""
        return _blocks_swig0.head_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(head_sptr self) -> uint64_t"""
        return _blocks_swig0.head_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(head_sptr self) -> uint64_t"""
        return _blocks_swig0.head_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(head_sptr self) -> bool"""
        return _blocks_swig0.head_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(head_sptr self) -> bool"""
        return _blocks_swig0.head_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(head_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.head_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(head_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.head_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(head_sptr self, std::string level)"""
        return _blocks_swig0.head_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(head_sptr self) -> std::string"""
        return _blocks_swig0.head_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(head_sptr self) -> int"""
        return _blocks_swig0.head_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(head_sptr self, int m)"""
        return _blocks_swig0.head_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(head_sptr self)"""
        return _blocks_swig0.head_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(head_sptr self) -> bool"""
        return _blocks_swig0.head_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(head_sptr self, int m)"""
        return _blocks_swig0.head_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(head_sptr self) -> int"""
        return _blocks_swig0.head_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(head_sptr self, int i) -> long"""
        return _blocks_swig0.head_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(head_sptr self, long max_output_buffer)
        set_max_output_buffer(head_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.head_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(head_sptr self, int i) -> long"""
        return _blocks_swig0.head_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(head_sptr self, long min_output_buffer)
        set_min_output_buffer(head_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.head_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(head_sptr self) -> float"""
        return _blocks_swig0.head_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(head_sptr self) -> float"""
        return _blocks_swig0.head_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(head_sptr self) -> float"""
        return _blocks_swig0.head_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(head_sptr self) -> float"""
        return _blocks_swig0.head_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(head_sptr self) -> float"""
        return _blocks_swig0.head_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(head_sptr self) -> float"""
        return _blocks_swig0.head_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(head_sptr self, int which) -> float
        pc_input_buffers_full(head_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.head_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(head_sptr self, int which) -> float
        pc_input_buffers_full_avg(head_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.head_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(head_sptr self, int which) -> float
        pc_input_buffers_full_var(head_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.head_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(head_sptr self, int which) -> float
        pc_output_buffers_full(head_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.head_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(head_sptr self, int which) -> float
        pc_output_buffers_full_avg(head_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.head_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(head_sptr self, int which) -> float
        pc_output_buffers_full_var(head_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.head_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(head_sptr self) -> float"""
        return _blocks_swig0.head_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(head_sptr self) -> float"""
        return _blocks_swig0.head_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(head_sptr self) -> float"""
        return _blocks_swig0.head_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(head_sptr self) -> float"""
        return _blocks_swig0.head_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(head_sptr self) -> float"""
        return _blocks_swig0.head_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(head_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.head_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(head_sptr self)"""
        return _blocks_swig0.head_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(head_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.head_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(head_sptr self) -> int"""
        return _blocks_swig0.head_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(head_sptr self) -> int"""
        return _blocks_swig0.head_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(head_sptr self, int priority) -> int"""
        return _blocks_swig0.head_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(head_sptr self) -> std::string"""
        return _blocks_swig0.head_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(head_sptr self) -> std::string"""
        return _blocks_swig0.head_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(head_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.head_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(head_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.head_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(head_sptr self) -> long"""
        return _blocks_swig0.head_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(head_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.head_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(head_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.head_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(head_sptr self) -> std::string"""
        return _blocks_swig0.head_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(head_sptr self, std::string name)"""
        return _blocks_swig0.head_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(head_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig0.head_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(head_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig0.head_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(head_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig0.head_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(head_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig0.head_sptr_message_subscribers(self, which_port)

# Register head_sptr in _blocks_swig0:
_blocks_swig0.head_sptr_swigregister(head_sptr)


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

class message_debug_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::message_debug > 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__(message_debug_sptr self) -> message_debug_sptr
        __init__(message_debug_sptr self, message_debug p) -> message_debug_sptr
        """
        _blocks_swig0.message_debug_sptr_swiginit(self, _blocks_swig0.new_message_debug_sptr(*args))

    def __deref__(self) -> "gr::blocks::message_debug *":
        r"""__deref__(message_debug_sptr self) -> message_debug"""
        return _blocks_swig0.message_debug_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig0.delete_message_debug_sptr

    def make(self) -> "gr::blocks::message_debug::sptr":
        r"""make(message_debug_sptr self) -> message_debug_sptr"""
        return _blocks_swig0.message_debug_sptr_make(self)

    def num_messages(self) -> "int":
        r"""num_messages(message_debug_sptr self) -> int"""
        return _blocks_swig0.message_debug_sptr_num_messages(self)

    def get_message(self, i: "int") -> "pmt::pmt_t":
        r"""get_message(message_debug_sptr self, int i) -> swig_pmt_ptr"""
        return _blocks_swig0.message_debug_sptr_get_message(self, i)

    def history(self) -> "unsigned int":
        r"""history(message_debug_sptr self) -> unsigned int"""
        return _blocks_swig0.message_debug_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(message_debug_sptr self, int which, int delay)
        declare_sample_delay(message_debug_sptr self, unsigned int delay)
        """
        return _blocks_swig0.message_debug_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(message_debug_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.message_debug_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(message_debug_sptr self, int multiple)"""
        return _blocks_swig0.message_debug_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(message_debug_sptr self) -> int"""
        return _blocks_swig0.message_debug_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(message_debug_sptr self) -> double"""
        return _blocks_swig0.message_debug_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(message_debug_sptr self) -> uint64_t"""
        return _blocks_swig0.message_debug_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(message_debug_sptr self) -> uint64_t"""
        return _blocks_swig0.message_debug_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(message_debug_sptr self) -> bool"""
        return _blocks_swig0.message_debug_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(message_debug_sptr self) -> bool"""
        return _blocks_swig0.message_debug_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(message_debug_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.message_debug_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(message_debug_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.message_debug_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(message_debug_sptr self, std::string level)"""
        return _blocks_swig0.message_debug_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(message_debug_sptr self) -> std::string"""
        return _blocks_swig0.message_debug_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(message_debug_sptr self) -> int"""
        return _blocks_swig0.message_debug_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(message_debug_sptr self, int m)"""
        return _blocks_swig0.message_debug_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(message_debug_sptr self)"""
        return _blocks_swig0.message_debug_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(message_debug_sptr self) -> bool"""
        return _blocks_swig0.message_debug_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(message_debug_sptr self, int m)"""
        return _blocks_swig0.message_debug_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(message_debug_sptr self) -> int"""
        return _blocks_swig0.message_debug_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(message_debug_sptr self, int i) -> long"""
        return _blocks_swig0.message_debug_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(message_debug_sptr self, long max_output_buffer)
        set_max_output_buffer(message_debug_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.message_debug_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(message_debug_sptr self, int i) -> long"""
        return _blocks_swig0.message_debug_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(message_debug_sptr self, long min_output_buffer)
        set_min_output_buffer(message_debug_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.message_debug_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(message_debug_sptr self) -> float"""
        return _blocks_swig0.message_debug_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(message_debug_sptr self) -> float"""
        return _blocks_swig0.message_debug_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(message_debug_sptr self) -> float"""
        return _blocks_swig0.message_debug_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(message_debug_sptr self) -> float"""
        return _blocks_swig0.message_debug_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(message_debug_sptr self) -> float"""
        return _blocks_swig0.message_debug_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(message_debug_sptr self) -> float"""
        return _blocks_swig0.message_debug_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(message_debug_sptr self, int which) -> float
        pc_input_buffers_full(message_debug_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_debug_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(message_debug_sptr self, int which) -> float
        pc_input_buffers_full_avg(message_debug_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_debug_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(message_debug_sptr self, int which) -> float
        pc_input_buffers_full_var(message_debug_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_debug_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(message_debug_sptr self, int which) -> float
        pc_output_buffers_full(message_debug_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_debug_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(message_debug_sptr self, int which) -> float
        pc_output_buffers_full_avg(message_debug_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_debug_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(message_debug_sptr self, int which) -> float
        pc_output_buffers_full_var(message_debug_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_debug_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(message_debug_sptr self) -> float"""
        return _blocks_swig0.message_debug_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(message_debug_sptr self) -> float"""
        return _blocks_swig0.message_debug_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(message_debug_sptr self) -> float"""
        return _blocks_swig0.message_debug_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(message_debug_sptr self) -> float"""
        return _blocks_swig0.message_debug_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(message_debug_sptr self) -> float"""
        return _blocks_swig0.message_debug_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(message_debug_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.message_debug_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(message_debug_sptr self)"""
        return _blocks_swig0.message_debug_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(message_debug_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.message_debug_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(message_debug_sptr self) -> int"""
        return _blocks_swig0.message_debug_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(message_debug_sptr self) -> int"""
        return _blocks_swig0.message_debug_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(message_debug_sptr self, int priority) -> int"""
        return _blocks_swig0.message_debug_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(message_debug_sptr self) -> std::string"""
        return _blocks_swig0.message_debug_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(message_debug_sptr self) -> std::string"""
        return _blocks_swig0.message_debug_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(message_debug_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.message_debug_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(message_debug_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.message_debug_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(message_debug_sptr self) -> long"""
        return _blocks_swig0.message_debug_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(message_debug_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.message_debug_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(message_debug_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.message_debug_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(message_debug_sptr self) -> std::string"""
        return _blocks_swig0.message_debug_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(message_debug_sptr self, std::string name)"""
        return _blocks_swig0.message_debug_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(message_debug_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig0.message_debug_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(message_debug_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig0.message_debug_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(message_debug_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig0.message_debug_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(message_debug_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig0.message_debug_sptr_message_subscribers(self, which_port)

# Register message_debug_sptr in _blocks_swig0:
_blocks_swig0.message_debug_sptr_swigregister(message_debug_sptr)


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

class message_strobe_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::message_strobe > 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__(message_strobe_sptr self) -> message_strobe_sptr
        __init__(message_strobe_sptr self, message_strobe p) -> message_strobe_sptr
        """
        _blocks_swig0.message_strobe_sptr_swiginit(self, _blocks_swig0.new_message_strobe_sptr(*args))

    def __deref__(self) -> "gr::blocks::message_strobe *":
        r"""__deref__(message_strobe_sptr self) -> message_strobe"""
        return _blocks_swig0.message_strobe_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig0.delete_message_strobe_sptr

    def make(self, msg: "swig_pmt_ptr", period_ms: "long") -> "gr::blocks::message_strobe::sptr":
        r"""make(message_strobe_sptr self, swig_pmt_ptr msg, long period_ms) -> message_strobe_sptr"""
        return _blocks_swig0.message_strobe_sptr_make(self, msg, period_ms)

    def set_msg(self, msg: "swig_pmt_ptr") -> "void":
        r"""set_msg(message_strobe_sptr self, swig_pmt_ptr msg)"""
        return _blocks_swig0.message_strobe_sptr_set_msg(self, msg)

    def msg(self) -> "pmt::pmt_t":
        r"""msg(message_strobe_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig0.message_strobe_sptr_msg(self)

    def set_period(self, period_ms: "long") -> "void":
        r"""set_period(message_strobe_sptr self, long period_ms)"""
        return _blocks_swig0.message_strobe_sptr_set_period(self, period_ms)

    def period(self) -> "long":
        r"""period(message_strobe_sptr self) -> long"""
        return _blocks_swig0.message_strobe_sptr_period(self)

    def history(self) -> "unsigned int":
        r"""history(message_strobe_sptr self) -> unsigned int"""
        return _blocks_swig0.message_strobe_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(message_strobe_sptr self, int which, int delay)
        declare_sample_delay(message_strobe_sptr self, unsigned int delay)
        """
        return _blocks_swig0.message_strobe_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(message_strobe_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.message_strobe_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(message_strobe_sptr self, int multiple)"""
        return _blocks_swig0.message_strobe_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(message_strobe_sptr self) -> int"""
        return _blocks_swig0.message_strobe_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(message_strobe_sptr self) -> double"""
        return _blocks_swig0.message_strobe_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(message_strobe_sptr self) -> uint64_t"""
        return _blocks_swig0.message_strobe_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(message_strobe_sptr self) -> uint64_t"""
        return _blocks_swig0.message_strobe_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(message_strobe_sptr self) -> bool"""
        return _blocks_swig0.message_strobe_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(message_strobe_sptr self) -> bool"""
        return _blocks_swig0.message_strobe_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(message_strobe_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.message_strobe_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(message_strobe_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.message_strobe_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(message_strobe_sptr self, std::string level)"""
        return _blocks_swig0.message_strobe_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(message_strobe_sptr self) -> std::string"""
        return _blocks_swig0.message_strobe_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(message_strobe_sptr self) -> int"""
        return _blocks_swig0.message_strobe_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(message_strobe_sptr self, int m)"""
        return _blocks_swig0.message_strobe_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(message_strobe_sptr self)"""
        return _blocks_swig0.message_strobe_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(message_strobe_sptr self) -> bool"""
        return _blocks_swig0.message_strobe_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(message_strobe_sptr self, int m)"""
        return _blocks_swig0.message_strobe_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(message_strobe_sptr self) -> int"""
        return _blocks_swig0.message_strobe_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(message_strobe_sptr self, int i) -> long"""
        return _blocks_swig0.message_strobe_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(message_strobe_sptr self, long max_output_buffer)
        set_max_output_buffer(message_strobe_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.message_strobe_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(message_strobe_sptr self, int i) -> long"""
        return _blocks_swig0.message_strobe_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(message_strobe_sptr self, long min_output_buffer)
        set_min_output_buffer(message_strobe_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.message_strobe_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(message_strobe_sptr self) -> float"""
        return _blocks_swig0.message_strobe_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(message_strobe_sptr self) -> float"""
        return _blocks_swig0.message_strobe_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(message_strobe_sptr self) -> float"""
        return _blocks_swig0.message_strobe_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(message_strobe_sptr self) -> float"""
        return _blocks_swig0.message_strobe_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(message_strobe_sptr self) -> float"""
        return _blocks_swig0.message_strobe_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(message_strobe_sptr self) -> float"""
        return _blocks_swig0.message_strobe_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(message_strobe_sptr self, int which) -> float
        pc_input_buffers_full(message_strobe_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_strobe_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(message_strobe_sptr self, int which) -> float
        pc_input_buffers_full_avg(message_strobe_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_strobe_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(message_strobe_sptr self, int which) -> float
        pc_input_buffers_full_var(message_strobe_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_strobe_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(message_strobe_sptr self, int which) -> float
        pc_output_buffers_full(message_strobe_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_strobe_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(message_strobe_sptr self, int which) -> float
        pc_output_buffers_full_avg(message_strobe_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_strobe_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(message_strobe_sptr self, int which) -> float
        pc_output_buffers_full_var(message_strobe_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_strobe_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(message_strobe_sptr self) -> float"""
        return _blocks_swig0.message_strobe_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(message_strobe_sptr self) -> float"""
        return _blocks_swig0.message_strobe_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(message_strobe_sptr self) -> float"""
        return _blocks_swig0.message_strobe_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(message_strobe_sptr self) -> float"""
        return _blocks_swig0.message_strobe_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(message_strobe_sptr self) -> float"""
        return _blocks_swig0.message_strobe_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(message_strobe_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.message_strobe_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(message_strobe_sptr self)"""
        return _blocks_swig0.message_strobe_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(message_strobe_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.message_strobe_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(message_strobe_sptr self) -> int"""
        return _blocks_swig0.message_strobe_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(message_strobe_sptr self) -> int"""
        return _blocks_swig0.message_strobe_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(message_strobe_sptr self, int priority) -> int"""
        return _blocks_swig0.message_strobe_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(message_strobe_sptr self) -> std::string"""
        return _blocks_swig0.message_strobe_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(message_strobe_sptr self) -> std::string"""
        return _blocks_swig0.message_strobe_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(message_strobe_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.message_strobe_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(message_strobe_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.message_strobe_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(message_strobe_sptr self) -> long"""
        return _blocks_swig0.message_strobe_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(message_strobe_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.message_strobe_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(message_strobe_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.message_strobe_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(message_strobe_sptr self) -> std::string"""
        return _blocks_swig0.message_strobe_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(message_strobe_sptr self, std::string name)"""
        return _blocks_swig0.message_strobe_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(message_strobe_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig0.message_strobe_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(message_strobe_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig0.message_strobe_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(message_strobe_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig0.message_strobe_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(message_strobe_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig0.message_strobe_sptr_message_subscribers(self, which_port)

# Register message_strobe_sptr in _blocks_swig0:
_blocks_swig0.message_strobe_sptr_swigregister(message_strobe_sptr)


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

class message_strobe_random_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::message_strobe_random > 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__(message_strobe_random_sptr self) -> message_strobe_random_sptr
        __init__(message_strobe_random_sptr self, message_strobe_random p) -> message_strobe_random_sptr
        """
        _blocks_swig0.message_strobe_random_sptr_swiginit(self, _blocks_swig0.new_message_strobe_random_sptr(*args))

    def __deref__(self) -> "gr::blocks::message_strobe_random *":
        r"""__deref__(message_strobe_random_sptr self) -> message_strobe_random"""
        return _blocks_swig0.message_strobe_random_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig0.delete_message_strobe_random_sptr

    def make(self, msg: "swig_pmt_ptr", dist: "gr::blocks::message_strobe_random_distribution_t", mean_ms: "float", std_ms: "float") -> "gr::blocks::message_strobe_random::sptr":
        r"""make(message_strobe_random_sptr self, swig_pmt_ptr msg, gr::blocks::message_strobe_random_distribution_t dist, float mean_ms, float std_ms) -> message_strobe_random_sptr"""
        return _blocks_swig0.message_strobe_random_sptr_make(self, msg, dist, mean_ms, std_ms)

    def set_msg(self, msg: "swig_pmt_ptr") -> "void":
        r"""set_msg(message_strobe_random_sptr self, swig_pmt_ptr msg)"""
        return _blocks_swig0.message_strobe_random_sptr_set_msg(self, msg)

    def msg(self) -> "pmt::pmt_t":
        r"""msg(message_strobe_random_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig0.message_strobe_random_sptr_msg(self)

    def set_dist(self, dist: "gr::blocks::message_strobe_random_distribution_t") -> "void":
        r"""set_dist(message_strobe_random_sptr self, gr::blocks::message_strobe_random_distribution_t dist)"""
        return _blocks_swig0.message_strobe_random_sptr_set_dist(self, dist)

    def dist(self) -> "gr::blocks::message_strobe_random_distribution_t":
        r"""dist(message_strobe_random_sptr self) -> gr::blocks::message_strobe_random_distribution_t"""
        return _blocks_swig0.message_strobe_random_sptr_dist(self)

    def set_mean(self, mean: "float") -> "void":
        r"""set_mean(message_strobe_random_sptr self, float mean)"""
        return _blocks_swig0.message_strobe_random_sptr_set_mean(self, mean)

    def mean(self) -> "float":
        r"""mean(message_strobe_random_sptr self) -> float"""
        return _blocks_swig0.message_strobe_random_sptr_mean(self)

    def set_std(self, std: "float") -> "void":
        r"""set_std(message_strobe_random_sptr self, float std)"""
        return _blocks_swig0.message_strobe_random_sptr_set_std(self, std)

    def std(self) -> "float":
        r"""std(message_strobe_random_sptr self) -> float"""
        return _blocks_swig0.message_strobe_random_sptr_std(self)

    def history(self) -> "unsigned int":
        r"""history(message_strobe_random_sptr self) -> unsigned int"""
        return _blocks_swig0.message_strobe_random_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(message_strobe_random_sptr self, int which, int delay)
        declare_sample_delay(message_strobe_random_sptr self, unsigned int delay)
        """
        return _blocks_swig0.message_strobe_random_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(message_strobe_random_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.message_strobe_random_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(message_strobe_random_sptr self, int multiple)"""
        return _blocks_swig0.message_strobe_random_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(message_strobe_random_sptr self) -> int"""
        return _blocks_swig0.message_strobe_random_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(message_strobe_random_sptr self) -> double"""
        return _blocks_swig0.message_strobe_random_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(message_strobe_random_sptr self) -> uint64_t"""
        return _blocks_swig0.message_strobe_random_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(message_strobe_random_sptr self) -> uint64_t"""
        return _blocks_swig0.message_strobe_random_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(message_strobe_random_sptr self) -> bool"""
        return _blocks_swig0.message_strobe_random_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(message_strobe_random_sptr self) -> bool"""
        return _blocks_swig0.message_strobe_random_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(message_strobe_random_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.message_strobe_random_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(message_strobe_random_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.message_strobe_random_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(message_strobe_random_sptr self, std::string level)"""
        return _blocks_swig0.message_strobe_random_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(message_strobe_random_sptr self) -> std::string"""
        return _blocks_swig0.message_strobe_random_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(message_strobe_random_sptr self) -> int"""
        return _blocks_swig0.message_strobe_random_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(message_strobe_random_sptr self, int m)"""
        return _blocks_swig0.message_strobe_random_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(message_strobe_random_sptr self)"""
        return _blocks_swig0.message_strobe_random_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(message_strobe_random_sptr self) -> bool"""
        return _blocks_swig0.message_strobe_random_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(message_strobe_random_sptr self, int m)"""
        return _blocks_swig0.message_strobe_random_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(message_strobe_random_sptr self) -> int"""
        return _blocks_swig0.message_strobe_random_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(message_strobe_random_sptr self, int i) -> long"""
        return _blocks_swig0.message_strobe_random_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(message_strobe_random_sptr self, long max_output_buffer)
        set_max_output_buffer(message_strobe_random_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.message_strobe_random_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(message_strobe_random_sptr self, int i) -> long"""
        return _blocks_swig0.message_strobe_random_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(message_strobe_random_sptr self, long min_output_buffer)
        set_min_output_buffer(message_strobe_random_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.message_strobe_random_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(message_strobe_random_sptr self) -> float"""
        return _blocks_swig0.message_strobe_random_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(message_strobe_random_sptr self) -> float"""
        return _blocks_swig0.message_strobe_random_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(message_strobe_random_sptr self) -> float"""
        return _blocks_swig0.message_strobe_random_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(message_strobe_random_sptr self) -> float"""
        return _blocks_swig0.message_strobe_random_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(message_strobe_random_sptr self) -> float"""
        return _blocks_swig0.message_strobe_random_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(message_strobe_random_sptr self) -> float"""
        return _blocks_swig0.message_strobe_random_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(message_strobe_random_sptr self, int which) -> float
        pc_input_buffers_full(message_strobe_random_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_strobe_random_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(message_strobe_random_sptr self, int which) -> float
        pc_input_buffers_full_avg(message_strobe_random_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_strobe_random_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(message_strobe_random_sptr self, int which) -> float
        pc_input_buffers_full_var(message_strobe_random_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_strobe_random_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(message_strobe_random_sptr self, int which) -> float
        pc_output_buffers_full(message_strobe_random_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_strobe_random_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(message_strobe_random_sptr self, int which) -> float
        pc_output_buffers_full_avg(message_strobe_random_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_strobe_random_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(message_strobe_random_sptr self, int which) -> float
        pc_output_buffers_full_var(message_strobe_random_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_strobe_random_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(message_strobe_random_sptr self) -> float"""
        return _blocks_swig0.message_strobe_random_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(message_strobe_random_sptr self) -> float"""
        return _blocks_swig0.message_strobe_random_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(message_strobe_random_sptr self) -> float"""
        return _blocks_swig0.message_strobe_random_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(message_strobe_random_sptr self) -> float"""
        return _blocks_swig0.message_strobe_random_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(message_strobe_random_sptr self) -> float"""
        return _blocks_swig0.message_strobe_random_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(message_strobe_random_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.message_strobe_random_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(message_strobe_random_sptr self)"""
        return _blocks_swig0.message_strobe_random_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(message_strobe_random_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.message_strobe_random_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(message_strobe_random_sptr self) -> int"""
        return _blocks_swig0.message_strobe_random_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(message_strobe_random_sptr self) -> int"""
        return _blocks_swig0.message_strobe_random_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(message_strobe_random_sptr self, int priority) -> int"""
        return _blocks_swig0.message_strobe_random_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(message_strobe_random_sptr self) -> std::string"""
        return _blocks_swig0.message_strobe_random_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(message_strobe_random_sptr self) -> std::string"""
        return _blocks_swig0.message_strobe_random_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(message_strobe_random_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.message_strobe_random_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(message_strobe_random_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.message_strobe_random_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(message_strobe_random_sptr self) -> long"""
        return _blocks_swig0.message_strobe_random_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(message_strobe_random_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.message_strobe_random_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(message_strobe_random_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.message_strobe_random_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(message_strobe_random_sptr self) -> std::string"""
        return _blocks_swig0.message_strobe_random_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(message_strobe_random_sptr self, std::string name)"""
        return _blocks_swig0.message_strobe_random_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(message_strobe_random_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig0.message_strobe_random_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(message_strobe_random_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig0.message_strobe_random_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(message_strobe_random_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig0.message_strobe_random_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(message_strobe_random_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig0.message_strobe_random_sptr_message_subscribers(self, which_port)

# Register message_strobe_random_sptr in _blocks_swig0:
_blocks_swig0.message_strobe_random_sptr_swigregister(message_strobe_random_sptr)


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

class nop_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::nop > 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__(nop_sptr self) -> nop_sptr
        __init__(nop_sptr self, nop p) -> nop_sptr
        """
        _blocks_swig0.nop_sptr_swiginit(self, _blocks_swig0.new_nop_sptr(*args))

    def __deref__(self) -> "gr::blocks::nop *":
        r"""__deref__(nop_sptr self) -> nop"""
        return _blocks_swig0.nop_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig0.delete_nop_sptr

    def make(self, sizeof_stream_item: "size_t") -> "gr::blocks::nop::sptr":
        r"""make(nop_sptr self, size_t sizeof_stream_item) -> nop_sptr"""
        return _blocks_swig0.nop_sptr_make(self, sizeof_stream_item)

    def nmsgs_received(self) -> "int":
        r"""nmsgs_received(nop_sptr self) -> int"""
        return _blocks_swig0.nop_sptr_nmsgs_received(self)

    def ctrlport_test(self) -> "int":
        r"""ctrlport_test(nop_sptr self) -> int"""
        return _blocks_swig0.nop_sptr_ctrlport_test(self)

    def set_ctrlport_test(self, x: "int") -> "void":
        r"""set_ctrlport_test(nop_sptr self, int x)"""
        return _blocks_swig0.nop_sptr_set_ctrlport_test(self, x)

    def history(self) -> "unsigned int":
        r"""history(nop_sptr self) -> unsigned int"""
        return _blocks_swig0.nop_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(nop_sptr self, int which, int delay)
        declare_sample_delay(nop_sptr self, unsigned int delay)
        """
        return _blocks_swig0.nop_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(nop_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.nop_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(nop_sptr self, int multiple)"""
        return _blocks_swig0.nop_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(nop_sptr self) -> int"""
        return _blocks_swig0.nop_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(nop_sptr self) -> double"""
        return _blocks_swig0.nop_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(nop_sptr self) -> uint64_t"""
        return _blocks_swig0.nop_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(nop_sptr self) -> uint64_t"""
        return _blocks_swig0.nop_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(nop_sptr self) -> bool"""
        return _blocks_swig0.nop_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(nop_sptr self) -> bool"""
        return _blocks_swig0.nop_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(nop_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.nop_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(nop_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.nop_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(nop_sptr self, std::string level)"""
        return _blocks_swig0.nop_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(nop_sptr self) -> std::string"""
        return _blocks_swig0.nop_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(nop_sptr self) -> int"""
        return _blocks_swig0.nop_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(nop_sptr self, int m)"""
        return _blocks_swig0.nop_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(nop_sptr self)"""
        return _blocks_swig0.nop_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(nop_sptr self) -> bool"""
        return _blocks_swig0.nop_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(nop_sptr self, int m)"""
        return _blocks_swig0.nop_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(nop_sptr self) -> int"""
        return _blocks_swig0.nop_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(nop_sptr self, int i) -> long"""
        return _blocks_swig0.nop_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(nop_sptr self, long max_output_buffer)
        set_max_output_buffer(nop_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.nop_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(nop_sptr self, int i) -> long"""
        return _blocks_swig0.nop_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(nop_sptr self, long min_output_buffer)
        set_min_output_buffer(nop_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.nop_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(nop_sptr self) -> float"""
        return _blocks_swig0.nop_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(nop_sptr self) -> float"""
        return _blocks_swig0.nop_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(nop_sptr self) -> float"""
        return _blocks_swig0.nop_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(nop_sptr self) -> float"""
        return _blocks_swig0.nop_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(nop_sptr self) -> float"""
        return _blocks_swig0.nop_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(nop_sptr self) -> float"""
        return _blocks_swig0.nop_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(nop_sptr self, int which) -> float
        pc_input_buffers_full(nop_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.nop_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(nop_sptr self, int which) -> float
        pc_input_buffers_full_avg(nop_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.nop_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(nop_sptr self, int which) -> float
        pc_input_buffers_full_var(nop_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.nop_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(nop_sptr self, int which) -> float
        pc_output_buffers_full(nop_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.nop_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(nop_sptr self, int which) -> float
        pc_output_buffers_full_avg(nop_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.nop_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(nop_sptr self, int which) -> float
        pc_output_buffers_full_var(nop_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.nop_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(nop_sptr self) -> float"""
        return _blocks_swig0.nop_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(nop_sptr self) -> float"""
        return _blocks_swig0.nop_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(nop_sptr self) -> float"""
        return _blocks_swig0.nop_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(nop_sptr self) -> float"""
        return _blocks_swig0.nop_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(nop_sptr self) -> float"""
        return _blocks_swig0.nop_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(nop_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.nop_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(nop_sptr self)"""
        return _blocks_swig0.nop_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(nop_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.nop_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(nop_sptr self) -> int"""
        return _blocks_swig0.nop_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(nop_sptr self) -> int"""
        return _blocks_swig0.nop_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(nop_sptr self, int priority) -> int"""
        return _blocks_swig0.nop_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(nop_sptr self) -> std::string"""
        return _blocks_swig0.nop_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(nop_sptr self) -> std::string"""
        return _blocks_swig0.nop_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(nop_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.nop_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(nop_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.nop_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(nop_sptr self) -> long"""
        return _blocks_swig0.nop_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(nop_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.nop_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(nop_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.nop_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(nop_sptr self) -> std::string"""
        return _blocks_swig0.nop_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(nop_sptr self, std::string name)"""
        return _blocks_swig0.nop_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(nop_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig0.nop_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(nop_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig0.nop_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(nop_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig0.nop_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(nop_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig0.nop_sptr_message_subscribers(self, which_port)

# Register nop_sptr in _blocks_swig0:
_blocks_swig0.nop_sptr_swigregister(nop_sptr)


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

class null_sink_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::null_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__(null_sink_sptr self) -> null_sink_sptr
        __init__(null_sink_sptr self, null_sink p) -> null_sink_sptr
        """
        _blocks_swig0.null_sink_sptr_swiginit(self, _blocks_swig0.new_null_sink_sptr(*args))

    def __deref__(self) -> "gr::blocks::null_sink *":
        r"""__deref__(null_sink_sptr self) -> null_sink"""
        return _blocks_swig0.null_sink_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig0.delete_null_sink_sptr

    def make(self, sizeof_stream_item: "size_t") -> "gr::blocks::null_sink::sptr":
        r"""make(null_sink_sptr self, size_t sizeof_stream_item) -> null_sink_sptr"""
        return _blocks_swig0.null_sink_sptr_make(self, sizeof_stream_item)

    def history(self) -> "unsigned int":
        r"""history(null_sink_sptr self) -> unsigned int"""
        return _blocks_swig0.null_sink_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(null_sink_sptr self, int which, int delay)
        declare_sample_delay(null_sink_sptr self, unsigned int delay)
        """
        return _blocks_swig0.null_sink_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(null_sink_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.null_sink_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(null_sink_sptr self, int multiple)"""
        return _blocks_swig0.null_sink_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(null_sink_sptr self) -> int"""
        return _blocks_swig0.null_sink_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(null_sink_sptr self) -> double"""
        return _blocks_swig0.null_sink_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(null_sink_sptr self) -> uint64_t"""
        return _blocks_swig0.null_sink_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(null_sink_sptr self) -> uint64_t"""
        return _blocks_swig0.null_sink_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(null_sink_sptr self) -> bool"""
        return _blocks_swig0.null_sink_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(null_sink_sptr self) -> bool"""
        return _blocks_swig0.null_sink_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(null_sink_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.null_sink_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(null_sink_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.null_sink_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(null_sink_sptr self, std::string level)"""
        return _blocks_swig0.null_sink_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(null_sink_sptr self) -> std::string"""
        return _blocks_swig0.null_sink_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(null_sink_sptr self) -> int"""
        return _blocks_swig0.null_sink_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(null_sink_sptr self, int m)"""
        return _blocks_swig0.null_sink_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(null_sink_sptr self)"""
        return _blocks_swig0.null_sink_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(null_sink_sptr self) -> bool"""
        return _blocks_swig0.null_sink_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(null_sink_sptr self, int m)"""
        return _blocks_swig0.null_sink_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(null_sink_sptr self) -> int"""
        return _blocks_swig0.null_sink_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(null_sink_sptr self, int i) -> long"""
        return _blocks_swig0.null_sink_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(null_sink_sptr self, long max_output_buffer)
        set_max_output_buffer(null_sink_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.null_sink_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(null_sink_sptr self, int i) -> long"""
        return _blocks_swig0.null_sink_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(null_sink_sptr self, long min_output_buffer)
        set_min_output_buffer(null_sink_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.null_sink_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(null_sink_sptr self) -> float"""
        return _blocks_swig0.null_sink_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(null_sink_sptr self) -> float"""
        return _blocks_swig0.null_sink_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(null_sink_sptr self) -> float"""
        return _blocks_swig0.null_sink_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(null_sink_sptr self) -> float"""
        return _blocks_swig0.null_sink_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(null_sink_sptr self) -> float"""
        return _blocks_swig0.null_sink_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(null_sink_sptr self) -> float"""
        return _blocks_swig0.null_sink_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(null_sink_sptr self, int which) -> float
        pc_input_buffers_full(null_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.null_sink_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(null_sink_sptr self, int which) -> float
        pc_input_buffers_full_avg(null_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.null_sink_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(null_sink_sptr self, int which) -> float
        pc_input_buffers_full_var(null_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.null_sink_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(null_sink_sptr self, int which) -> float
        pc_output_buffers_full(null_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.null_sink_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(null_sink_sptr self, int which) -> float
        pc_output_buffers_full_avg(null_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.null_sink_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(null_sink_sptr self, int which) -> float
        pc_output_buffers_full_var(null_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.null_sink_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(null_sink_sptr self) -> float"""
        return _blocks_swig0.null_sink_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(null_sink_sptr self) -> float"""
        return _blocks_swig0.null_sink_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(null_sink_sptr self) -> float"""
        return _blocks_swig0.null_sink_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(null_sink_sptr self) -> float"""
        return _blocks_swig0.null_sink_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(null_sink_sptr self) -> float"""
        return _blocks_swig0.null_sink_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(null_sink_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.null_sink_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(null_sink_sptr self)"""
        return _blocks_swig0.null_sink_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(null_sink_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.null_sink_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(null_sink_sptr self) -> int"""
        return _blocks_swig0.null_sink_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(null_sink_sptr self) -> int"""
        return _blocks_swig0.null_sink_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(null_sink_sptr self, int priority) -> int"""
        return _blocks_swig0.null_sink_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(null_sink_sptr self) -> std::string"""
        return _blocks_swig0.null_sink_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(null_sink_sptr self) -> std::string"""
        return _blocks_swig0.null_sink_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(null_sink_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.null_sink_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(null_sink_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.null_sink_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(null_sink_sptr self) -> long"""
        return _blocks_swig0.null_sink_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(null_sink_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.null_sink_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(null_sink_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.null_sink_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(null_sink_sptr self) -> std::string"""
        return _blocks_swig0.null_sink_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(null_sink_sptr self, std::string name)"""
        return _blocks_swig0.null_sink_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(null_sink_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig0.null_sink_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(null_sink_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig0.null_sink_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(null_sink_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig0.null_sink_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(null_sink_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig0.null_sink_sptr_message_subscribers(self, which_port)

# Register null_sink_sptr in _blocks_swig0:
_blocks_swig0.null_sink_sptr_swigregister(null_sink_sptr)


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

class null_source_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::null_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__(null_source_sptr self) -> null_source_sptr
        __init__(null_source_sptr self, null_source p) -> null_source_sptr
        """
        _blocks_swig0.null_source_sptr_swiginit(self, _blocks_swig0.new_null_source_sptr(*args))

    def __deref__(self) -> "gr::blocks::null_source *":
        r"""__deref__(null_source_sptr self) -> null_source"""
        return _blocks_swig0.null_source_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig0.delete_null_source_sptr

    def make(self, sizeof_stream_item: "size_t") -> "gr::blocks::null_source::sptr":
        r"""make(null_source_sptr self, size_t sizeof_stream_item) -> null_source_sptr"""
        return _blocks_swig0.null_source_sptr_make(self, sizeof_stream_item)

    def history(self) -> "unsigned int":
        r"""history(null_source_sptr self) -> unsigned int"""
        return _blocks_swig0.null_source_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(null_source_sptr self, int which, int delay)
        declare_sample_delay(null_source_sptr self, unsigned int delay)
        """
        return _blocks_swig0.null_source_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(null_source_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.null_source_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(null_source_sptr self, int multiple)"""
        return _blocks_swig0.null_source_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(null_source_sptr self) -> int"""
        return _blocks_swig0.null_source_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(null_source_sptr self) -> double"""
        return _blocks_swig0.null_source_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(null_source_sptr self) -> uint64_t"""
        return _blocks_swig0.null_source_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(null_source_sptr self) -> uint64_t"""
        return _blocks_swig0.null_source_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(null_source_sptr self) -> bool"""
        return _blocks_swig0.null_source_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(null_source_sptr self) -> bool"""
        return _blocks_swig0.null_source_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(null_source_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.null_source_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(null_source_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.null_source_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(null_source_sptr self, std::string level)"""
        return _blocks_swig0.null_source_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(null_source_sptr self) -> std::string"""
        return _blocks_swig0.null_source_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(null_source_sptr self) -> int"""
        return _blocks_swig0.null_source_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(null_source_sptr self, int m)"""
        return _blocks_swig0.null_source_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(null_source_sptr self)"""
        return _blocks_swig0.null_source_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(null_source_sptr self) -> bool"""
        return _blocks_swig0.null_source_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(null_source_sptr self, int m)"""
        return _blocks_swig0.null_source_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(null_source_sptr self) -> int"""
        return _blocks_swig0.null_source_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(null_source_sptr self, int i) -> long"""
        return _blocks_swig0.null_source_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(null_source_sptr self, long max_output_buffer)
        set_max_output_buffer(null_source_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.null_source_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(null_source_sptr self, int i) -> long"""
        return _blocks_swig0.null_source_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(null_source_sptr self, long min_output_buffer)
        set_min_output_buffer(null_source_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.null_source_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(null_source_sptr self) -> float"""
        return _blocks_swig0.null_source_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(null_source_sptr self) -> float"""
        return _blocks_swig0.null_source_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(null_source_sptr self) -> float"""
        return _blocks_swig0.null_source_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(null_source_sptr self) -> float"""
        return _blocks_swig0.null_source_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(null_source_sptr self) -> float"""
        return _blocks_swig0.null_source_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(null_source_sptr self) -> float"""
        return _blocks_swig0.null_source_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(null_source_sptr self, int which) -> float
        pc_input_buffers_full(null_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.null_source_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(null_source_sptr self, int which) -> float
        pc_input_buffers_full_avg(null_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.null_source_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(null_source_sptr self, int which) -> float
        pc_input_buffers_full_var(null_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.null_source_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(null_source_sptr self, int which) -> float
        pc_output_buffers_full(null_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.null_source_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(null_source_sptr self, int which) -> float
        pc_output_buffers_full_avg(null_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.null_source_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(null_source_sptr self, int which) -> float
        pc_output_buffers_full_var(null_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.null_source_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(null_source_sptr self) -> float"""
        return _blocks_swig0.null_source_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(null_source_sptr self) -> float"""
        return _blocks_swig0.null_source_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(null_source_sptr self) -> float"""
        return _blocks_swig0.null_source_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(null_source_sptr self) -> float"""
        return _blocks_swig0.null_source_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(null_source_sptr self) -> float"""
        return _blocks_swig0.null_source_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(null_source_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.null_source_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(null_source_sptr self)"""
        return _blocks_swig0.null_source_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(null_source_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.null_source_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(null_source_sptr self) -> int"""
        return _blocks_swig0.null_source_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(null_source_sptr self) -> int"""
        return _blocks_swig0.null_source_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(null_source_sptr self, int priority) -> int"""
        return _blocks_swig0.null_source_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(null_source_sptr self) -> std::string"""
        return _blocks_swig0.null_source_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(null_source_sptr self) -> std::string"""
        return _blocks_swig0.null_source_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(null_source_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.null_source_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(null_source_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.null_source_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(null_source_sptr self) -> long"""
        return _blocks_swig0.null_source_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(null_source_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.null_source_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(null_source_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.null_source_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(null_source_sptr self) -> std::string"""
        return _blocks_swig0.null_source_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(null_source_sptr self, std::string name)"""
        return _blocks_swig0.null_source_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(null_source_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig0.null_source_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(null_source_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig0.null_source_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(null_source_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig0.null_source_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(null_source_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig0.null_source_sptr_message_subscribers(self, which_port)

# Register null_source_sptr in _blocks_swig0:
_blocks_swig0.null_source_sptr_swigregister(null_source_sptr)


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

class ctrlport_probe_c(object):
    r"""Proxy of C++ gr::blocks::ctrlport_probe_c class."""

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

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

    @staticmethod
    def make(id: "std::string const &", desc: "std::string const &") -> "gr::blocks::ctrlport_probe_c::sptr":
        r"""make(std::string const & id, std::string const & desc) -> ctrlport_probe_c_sptr"""
        return _blocks_swig0.ctrlport_probe_c_make(id, desc)

    def get(self) -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""get(ctrlport_probe_c self) -> pmt_vector_cfloat"""
        return _blocks_swig0.ctrlport_probe_c_get(self)
    __swig_destroy__ = _blocks_swig0.delete_ctrlport_probe_c

# Register ctrlport_probe_c in _blocks_swig0:
_blocks_swig0.ctrlport_probe_c_swigregister(ctrlport_probe_c)

def ctrlport_probe_c_make(id: "std::string const &", desc: "std::string const &") -> "gr::blocks::ctrlport_probe_c::sptr":
    r"""ctrlport_probe_c_make(std::string const & id, std::string const & desc) -> ctrlport_probe_c_sptr"""
    return _blocks_swig0.ctrlport_probe_c_make(id, desc)

class ctrlport_probe2_c(object):
    r"""Proxy of C++ gr::blocks::ctrlport_probe2_c class."""

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

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

    @staticmethod
    def make(id: "std::string const &", desc: "std::string const &", len: "int", disp_mask: "unsigned int") -> "gr::blocks::ctrlport_probe2_c::sptr":
        r"""make(std::string const & id, std::string const & desc, int len, unsigned int disp_mask) -> ctrlport_probe2_c_sptr"""
        return _blocks_swig0.ctrlport_probe2_c_make(id, desc, len, disp_mask)

    def get(self) -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""get(ctrlport_probe2_c self) -> pmt_vector_cfloat"""
        return _blocks_swig0.ctrlport_probe2_c_get(self)

    def set_length(self, len: "int") -> "void":
        r"""set_length(ctrlport_probe2_c self, int len)"""
        return _blocks_swig0.ctrlport_probe2_c_set_length(self, len)

    def length(self) -> "int":
        r"""length(ctrlport_probe2_c self) -> int"""
        return _blocks_swig0.ctrlport_probe2_c_length(self)
    __swig_destroy__ = _blocks_swig0.delete_ctrlport_probe2_c

# Register ctrlport_probe2_c in _blocks_swig0:
_blocks_swig0.ctrlport_probe2_c_swigregister(ctrlport_probe2_c)

def ctrlport_probe2_c_make(id: "std::string const &", desc: "std::string const &", len: "int", disp_mask: "unsigned int") -> "gr::blocks::ctrlport_probe2_c::sptr":
    r"""ctrlport_probe2_c_make(std::string const & id, std::string const & desc, int len, unsigned int disp_mask) -> ctrlport_probe2_c_sptr"""
    return _blocks_swig0.ctrlport_probe2_c_make(id, desc, len, disp_mask)

class ctrlport_probe2_f(object):
    r"""Proxy of C++ gr::blocks::ctrlport_probe2_f class."""

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

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

    @staticmethod
    def make(id: "std::string const &", desc: "std::string const &", len: "int", disp_mask: "unsigned int") -> "gr::blocks::ctrlport_probe2_f::sptr":
        r"""make(std::string const & id, std::string const & desc, int len, unsigned int disp_mask) -> ctrlport_probe2_f_sptr"""
        return _blocks_swig0.ctrlport_probe2_f_make(id, desc, len, disp_mask)

    def get(self) -> "std::vector< float,std::allocator< float > >":
        r"""get(ctrlport_probe2_f self) -> pmt_vector_float"""
        return _blocks_swig0.ctrlport_probe2_f_get(self)

    def set_length(self, len: "int") -> "void":
        r"""set_length(ctrlport_probe2_f self, int len)"""
        return _blocks_swig0.ctrlport_probe2_f_set_length(self, len)

    def length(self) -> "int":
        r"""length(ctrlport_probe2_f self) -> int"""
        return _blocks_swig0.ctrlport_probe2_f_length(self)
    __swig_destroy__ = _blocks_swig0.delete_ctrlport_probe2_f

# Register ctrlport_probe2_f in _blocks_swig0:
_blocks_swig0.ctrlport_probe2_f_swigregister(ctrlport_probe2_f)

def ctrlport_probe2_f_make(id: "std::string const &", desc: "std::string const &", len: "int", disp_mask: "unsigned int") -> "gr::blocks::ctrlport_probe2_f::sptr":
    r"""ctrlport_probe2_f_make(std::string const & id, std::string const & desc, int len, unsigned int disp_mask) -> ctrlport_probe2_f_sptr"""
    return _blocks_swig0.ctrlport_probe2_f_make(id, desc, len, disp_mask)

class ctrlport_probe2_s(object):
    r"""Proxy of C++ gr::blocks::ctrlport_probe2_s class."""

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

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

    @staticmethod
    def make(id: "std::string const &", desc: "std::string const &", len: "int", disp_mask: "unsigned int") -> "gr::blocks::ctrlport_probe2_s::sptr":
        r"""make(std::string const & id, std::string const & desc, int len, unsigned int disp_mask) -> ctrlport_probe2_s_sptr"""
        return _blocks_swig0.ctrlport_probe2_s_make(id, desc, len, disp_mask)

    def get(self) -> "std::vector< short,std::allocator< short > >":
        r"""get(ctrlport_probe2_s self) -> std::vector< short,std::allocator< short > >"""
        return _blocks_swig0.ctrlport_probe2_s_get(self)

    def set_length(self, len: "int") -> "void":
        r"""set_length(ctrlport_probe2_s self, int len)"""
        return _blocks_swig0.ctrlport_probe2_s_set_length(self, len)

    def length(self) -> "int":
        r"""length(ctrlport_probe2_s self) -> int"""
        return _blocks_swig0.ctrlport_probe2_s_length(self)
    __swig_destroy__ = _blocks_swig0.delete_ctrlport_probe2_s

# Register ctrlport_probe2_s in _blocks_swig0:
_blocks_swig0.ctrlport_probe2_s_swigregister(ctrlport_probe2_s)

def ctrlport_probe2_s_make(id: "std::string const &", desc: "std::string const &", len: "int", disp_mask: "unsigned int") -> "gr::blocks::ctrlport_probe2_s::sptr":
    r"""ctrlport_probe2_s_make(std::string const & id, std::string const & desc, int len, unsigned int disp_mask) -> ctrlport_probe2_s_sptr"""
    return _blocks_swig0.ctrlport_probe2_s_make(id, desc, len, disp_mask)

class ctrlport_probe2_i(object):
    r"""Proxy of C++ gr::blocks::ctrlport_probe2_i class."""

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

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

    @staticmethod
    def make(id: "std::string const &", desc: "std::string const &", len: "int", disp_mask: "unsigned int") -> "gr::blocks::ctrlport_probe2_i::sptr":
        r"""make(std::string const & id, std::string const & desc, int len, unsigned int disp_mask) -> ctrlport_probe2_i_sptr"""
        return _blocks_swig0.ctrlport_probe2_i_make(id, desc, len, disp_mask)

    def get(self) -> "std::vector< int,std::allocator< int > >":
        r"""get(ctrlport_probe2_i self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.ctrlport_probe2_i_get(self)

    def set_length(self, len: "int") -> "void":
        r"""set_length(ctrlport_probe2_i self, int len)"""
        return _blocks_swig0.ctrlport_probe2_i_set_length(self, len)

    def length(self) -> "int":
        r"""length(ctrlport_probe2_i self) -> int"""
        return _blocks_swig0.ctrlport_probe2_i_length(self)
    __swig_destroy__ = _blocks_swig0.delete_ctrlport_probe2_i

# Register ctrlport_probe2_i in _blocks_swig0:
_blocks_swig0.ctrlport_probe2_i_swigregister(ctrlport_probe2_i)

def ctrlport_probe2_i_make(id: "std::string const &", desc: "std::string const &", len: "int", disp_mask: "unsigned int") -> "gr::blocks::ctrlport_probe2_i::sptr":
    r"""ctrlport_probe2_i_make(std::string const & id, std::string const & desc, int len, unsigned int disp_mask) -> ctrlport_probe2_i_sptr"""
    return _blocks_swig0.ctrlport_probe2_i_make(id, desc, len, disp_mask)

class ctrlport_probe2_b(object):
    r"""Proxy of C++ gr::blocks::ctrlport_probe2_b class."""

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

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

    @staticmethod
    def make(id: "std::string const &", desc: "std::string const &", len: "int", disp_mask: "unsigned int") -> "gr::blocks::ctrlport_probe2_b::sptr":
        r"""make(std::string const & id, std::string const & desc, int len, unsigned int disp_mask) -> ctrlport_probe2_b_sptr"""
        return _blocks_swig0.ctrlport_probe2_b_make(id, desc, len, disp_mask)

    def get(self) -> "std::vector< signed char,std::allocator< signed char > >":
        r"""get(ctrlport_probe2_b self) -> std::vector< signed char,std::allocator< signed char > >"""
        return _blocks_swig0.ctrlport_probe2_b_get(self)

    def set_length(self, len: "int") -> "void":
        r"""set_length(ctrlport_probe2_b self, int len)"""
        return _blocks_swig0.ctrlport_probe2_b_set_length(self, len)

    def length(self) -> "int":
        r"""length(ctrlport_probe2_b self) -> int"""
        return _blocks_swig0.ctrlport_probe2_b_length(self)
    __swig_destroy__ = _blocks_swig0.delete_ctrlport_probe2_b

# Register ctrlport_probe2_b in _blocks_swig0:
_blocks_swig0.ctrlport_probe2_b_swigregister(ctrlport_probe2_b)

def ctrlport_probe2_b_make(id: "std::string const &", desc: "std::string const &", len: "int", disp_mask: "unsigned int") -> "gr::blocks::ctrlport_probe2_b::sptr":
    r"""ctrlport_probe2_b_make(std::string const & id, std::string const & desc, int len, unsigned int disp_mask) -> ctrlport_probe2_b_sptr"""
    return _blocks_swig0.ctrlport_probe2_b_make(id, desc, len, disp_mask)

class ctrlport_probe_c_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::ctrlport_probe_c > 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__(ctrlport_probe_c_sptr self) -> ctrlport_probe_c_sptr
        __init__(ctrlport_probe_c_sptr self, ctrlport_probe_c p) -> ctrlport_probe_c_sptr
        """
        _blocks_swig0.ctrlport_probe_c_sptr_swiginit(self, _blocks_swig0.new_ctrlport_probe_c_sptr(*args))

    def __deref__(self) -> "gr::blocks::ctrlport_probe_c *":
        r"""__deref__(ctrlport_probe_c_sptr self) -> ctrlport_probe_c"""
        return _blocks_swig0.ctrlport_probe_c_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig0.delete_ctrlport_probe_c_sptr

    def make(self, id: "std::string const &", desc: "std::string const &") -> "gr::blocks::ctrlport_probe_c::sptr":
        r"""make(ctrlport_probe_c_sptr self, std::string const & id, std::string const & desc) -> ctrlport_probe_c_sptr"""
        return _blocks_swig0.ctrlport_probe_c_sptr_make(self, id, desc)

    def get(self) -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""get(ctrlport_probe_c_sptr self) -> pmt_vector_cfloat"""
        return _blocks_swig0.ctrlport_probe_c_sptr_get(self)

    def history(self) -> "unsigned int":
        r"""history(ctrlport_probe_c_sptr self) -> unsigned int"""
        return _blocks_swig0.ctrlport_probe_c_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(ctrlport_probe_c_sptr self, int which, int delay)
        declare_sample_delay(ctrlport_probe_c_sptr self, unsigned int delay)
        """
        return _blocks_swig0.ctrlport_probe_c_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(ctrlport_probe_c_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.ctrlport_probe_c_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(ctrlport_probe_c_sptr self, int multiple)"""
        return _blocks_swig0.ctrlport_probe_c_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(ctrlport_probe_c_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe_c_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(ctrlport_probe_c_sptr self) -> double"""
        return _blocks_swig0.ctrlport_probe_c_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(ctrlport_probe_c_sptr self) -> uint64_t"""
        return _blocks_swig0.ctrlport_probe_c_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(ctrlport_probe_c_sptr self) -> uint64_t"""
        return _blocks_swig0.ctrlport_probe_c_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(ctrlport_probe_c_sptr self) -> bool"""
        return _blocks_swig0.ctrlport_probe_c_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(ctrlport_probe_c_sptr self) -> bool"""
        return _blocks_swig0.ctrlport_probe_c_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(ctrlport_probe_c_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.ctrlport_probe_c_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(ctrlport_probe_c_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.ctrlport_probe_c_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(ctrlport_probe_c_sptr self, std::string level)"""
        return _blocks_swig0.ctrlport_probe_c_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(ctrlport_probe_c_sptr self) -> std::string"""
        return _blocks_swig0.ctrlport_probe_c_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(ctrlport_probe_c_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe_c_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(ctrlport_probe_c_sptr self, int m)"""
        return _blocks_swig0.ctrlport_probe_c_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(ctrlport_probe_c_sptr self)"""
        return _blocks_swig0.ctrlport_probe_c_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(ctrlport_probe_c_sptr self) -> bool"""
        return _blocks_swig0.ctrlport_probe_c_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(ctrlport_probe_c_sptr self, int m)"""
        return _blocks_swig0.ctrlport_probe_c_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(ctrlport_probe_c_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe_c_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(ctrlport_probe_c_sptr self, int i) -> long"""
        return _blocks_swig0.ctrlport_probe_c_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(ctrlport_probe_c_sptr self, long max_output_buffer)
        set_max_output_buffer(ctrlport_probe_c_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.ctrlport_probe_c_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(ctrlport_probe_c_sptr self, int i) -> long"""
        return _blocks_swig0.ctrlport_probe_c_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(ctrlport_probe_c_sptr self, long min_output_buffer)
        set_min_output_buffer(ctrlport_probe_c_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.ctrlport_probe_c_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(ctrlport_probe_c_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe_c_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(ctrlport_probe_c_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe_c_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(ctrlport_probe_c_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe_c_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(ctrlport_probe_c_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe_c_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(ctrlport_probe_c_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe_c_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(ctrlport_probe_c_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe_c_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(ctrlport_probe_c_sptr self, int which) -> float
        pc_input_buffers_full(ctrlport_probe_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe_c_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(ctrlport_probe_c_sptr self, int which) -> float
        pc_input_buffers_full_avg(ctrlport_probe_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe_c_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(ctrlport_probe_c_sptr self, int which) -> float
        pc_input_buffers_full_var(ctrlport_probe_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe_c_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(ctrlport_probe_c_sptr self, int which) -> float
        pc_output_buffers_full(ctrlport_probe_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe_c_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(ctrlport_probe_c_sptr self, int which) -> float
        pc_output_buffers_full_avg(ctrlport_probe_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe_c_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(ctrlport_probe_c_sptr self, int which) -> float
        pc_output_buffers_full_var(ctrlport_probe_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe_c_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(ctrlport_probe_c_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe_c_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(ctrlport_probe_c_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe_c_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(ctrlport_probe_c_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe_c_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(ctrlport_probe_c_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe_c_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(ctrlport_probe_c_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe_c_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(ctrlport_probe_c_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.ctrlport_probe_c_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(ctrlport_probe_c_sptr self)"""
        return _blocks_swig0.ctrlport_probe_c_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(ctrlport_probe_c_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.ctrlport_probe_c_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(ctrlport_probe_c_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe_c_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(ctrlport_probe_c_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe_c_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(ctrlport_probe_c_sptr self, int priority) -> int"""
        return _blocks_swig0.ctrlport_probe_c_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(ctrlport_probe_c_sptr self) -> std::string"""
        return _blocks_swig0.ctrlport_probe_c_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(ctrlport_probe_c_sptr self) -> std::string"""
        return _blocks_swig0.ctrlport_probe_c_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(ctrlport_probe_c_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.ctrlport_probe_c_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(ctrlport_probe_c_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.ctrlport_probe_c_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(ctrlport_probe_c_sptr self) -> long"""
        return _blocks_swig0.ctrlport_probe_c_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(ctrlport_probe_c_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.ctrlport_probe_c_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(ctrlport_probe_c_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.ctrlport_probe_c_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(ctrlport_probe_c_sptr self) -> std::string"""
        return _blocks_swig0.ctrlport_probe_c_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(ctrlport_probe_c_sptr self, std::string name)"""
        return _blocks_swig0.ctrlport_probe_c_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(ctrlport_probe_c_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig0.ctrlport_probe_c_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(ctrlport_probe_c_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig0.ctrlport_probe_c_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(ctrlport_probe_c_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig0.ctrlport_probe_c_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(ctrlport_probe_c_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig0.ctrlport_probe_c_sptr_message_subscribers(self, which_port)

# Register ctrlport_probe_c_sptr in _blocks_swig0:
_blocks_swig0.ctrlport_probe_c_sptr_swigregister(ctrlport_probe_c_sptr)


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

class ctrlport_probe2_c_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::ctrlport_probe2_c > 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__(ctrlport_probe2_c_sptr self) -> ctrlport_probe2_c_sptr
        __init__(ctrlport_probe2_c_sptr self, ctrlport_probe2_c p) -> ctrlport_probe2_c_sptr
        """
        _blocks_swig0.ctrlport_probe2_c_sptr_swiginit(self, _blocks_swig0.new_ctrlport_probe2_c_sptr(*args))

    def __deref__(self) -> "gr::blocks::ctrlport_probe2_c *":
        r"""__deref__(ctrlport_probe2_c_sptr self) -> ctrlport_probe2_c"""
        return _blocks_swig0.ctrlport_probe2_c_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig0.delete_ctrlport_probe2_c_sptr

    def make(self, id: "std::string const &", desc: "std::string const &", len: "int", disp_mask: "unsigned int") -> "gr::blocks::ctrlport_probe2_c::sptr":
        r"""make(ctrlport_probe2_c_sptr self, std::string const & id, std::string const & desc, int len, unsigned int disp_mask) -> ctrlport_probe2_c_sptr"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_make(self, id, desc, len, disp_mask)

    def get(self) -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""get(ctrlport_probe2_c_sptr self) -> pmt_vector_cfloat"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_get(self)

    def set_length(self, len: "int") -> "void":
        r"""set_length(ctrlport_probe2_c_sptr self, int len)"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_set_length(self, len)

    def length(self) -> "int":
        r"""length(ctrlport_probe2_c_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_length(self)

    def history(self) -> "unsigned int":
        r"""history(ctrlport_probe2_c_sptr self) -> unsigned int"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(ctrlport_probe2_c_sptr self, int which, int delay)
        declare_sample_delay(ctrlport_probe2_c_sptr self, unsigned int delay)
        """
        return _blocks_swig0.ctrlport_probe2_c_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(ctrlport_probe2_c_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(ctrlport_probe2_c_sptr self, int multiple)"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(ctrlport_probe2_c_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(ctrlport_probe2_c_sptr self) -> double"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(ctrlport_probe2_c_sptr self) -> uint64_t"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(ctrlport_probe2_c_sptr self) -> uint64_t"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(ctrlport_probe2_c_sptr self) -> bool"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(ctrlport_probe2_c_sptr self) -> bool"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(ctrlport_probe2_c_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(ctrlport_probe2_c_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(ctrlport_probe2_c_sptr self, std::string level)"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(ctrlport_probe2_c_sptr self) -> std::string"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(ctrlport_probe2_c_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(ctrlport_probe2_c_sptr self, int m)"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(ctrlport_probe2_c_sptr self)"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(ctrlport_probe2_c_sptr self) -> bool"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(ctrlport_probe2_c_sptr self, int m)"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(ctrlport_probe2_c_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(ctrlport_probe2_c_sptr self, int i) -> long"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(ctrlport_probe2_c_sptr self, long max_output_buffer)
        set_max_output_buffer(ctrlport_probe2_c_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.ctrlport_probe2_c_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(ctrlport_probe2_c_sptr self, int i) -> long"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(ctrlport_probe2_c_sptr self, long min_output_buffer)
        set_min_output_buffer(ctrlport_probe2_c_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.ctrlport_probe2_c_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(ctrlport_probe2_c_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(ctrlport_probe2_c_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(ctrlport_probe2_c_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(ctrlport_probe2_c_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(ctrlport_probe2_c_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(ctrlport_probe2_c_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(ctrlport_probe2_c_sptr self, int which) -> float
        pc_input_buffers_full(ctrlport_probe2_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe2_c_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(ctrlport_probe2_c_sptr self, int which) -> float
        pc_input_buffers_full_avg(ctrlport_probe2_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe2_c_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(ctrlport_probe2_c_sptr self, int which) -> float
        pc_input_buffers_full_var(ctrlport_probe2_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe2_c_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(ctrlport_probe2_c_sptr self, int which) -> float
        pc_output_buffers_full(ctrlport_probe2_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe2_c_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(ctrlport_probe2_c_sptr self, int which) -> float
        pc_output_buffers_full_avg(ctrlport_probe2_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe2_c_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(ctrlport_probe2_c_sptr self, int which) -> float
        pc_output_buffers_full_var(ctrlport_probe2_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe2_c_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(ctrlport_probe2_c_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(ctrlport_probe2_c_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(ctrlport_probe2_c_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(ctrlport_probe2_c_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(ctrlport_probe2_c_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(ctrlport_probe2_c_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(ctrlport_probe2_c_sptr self)"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(ctrlport_probe2_c_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(ctrlport_probe2_c_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(ctrlport_probe2_c_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(ctrlport_probe2_c_sptr self, int priority) -> int"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(ctrlport_probe2_c_sptr self) -> std::string"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(ctrlport_probe2_c_sptr self) -> std::string"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(ctrlport_probe2_c_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(ctrlport_probe2_c_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(ctrlport_probe2_c_sptr self) -> long"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(ctrlport_probe2_c_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(ctrlport_probe2_c_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(ctrlport_probe2_c_sptr self) -> std::string"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(ctrlport_probe2_c_sptr self, std::string name)"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(ctrlport_probe2_c_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig0.ctrlport_probe2_c_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(ctrlport_probe2_c_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(ctrlport_probe2_c_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(ctrlport_probe2_c_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_message_subscribers(self, which_port)

# Register ctrlport_probe2_c_sptr in _blocks_swig0:
_blocks_swig0.ctrlport_probe2_c_sptr_swigregister(ctrlport_probe2_c_sptr)


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

class ctrlport_probe2_f_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::ctrlport_probe2_f > 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__(ctrlport_probe2_f_sptr self) -> ctrlport_probe2_f_sptr
        __init__(ctrlport_probe2_f_sptr self, ctrlport_probe2_f p) -> ctrlport_probe2_f_sptr
        """
        _blocks_swig0.ctrlport_probe2_f_sptr_swiginit(self, _blocks_swig0.new_ctrlport_probe2_f_sptr(*args))

    def __deref__(self) -> "gr::blocks::ctrlport_probe2_f *":
        r"""__deref__(ctrlport_probe2_f_sptr self) -> ctrlport_probe2_f"""
        return _blocks_swig0.ctrlport_probe2_f_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig0.delete_ctrlport_probe2_f_sptr

    def make(self, id: "std::string const &", desc: "std::string const &", len: "int", disp_mask: "unsigned int") -> "gr::blocks::ctrlport_probe2_f::sptr":
        r"""make(ctrlport_probe2_f_sptr self, std::string const & id, std::string const & desc, int len, unsigned int disp_mask) -> ctrlport_probe2_f_sptr"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_make(self, id, desc, len, disp_mask)

    def get(self) -> "std::vector< float,std::allocator< float > >":
        r"""get(ctrlport_probe2_f_sptr self) -> pmt_vector_float"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_get(self)

    def set_length(self, len: "int") -> "void":
        r"""set_length(ctrlport_probe2_f_sptr self, int len)"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_set_length(self, len)

    def length(self) -> "int":
        r"""length(ctrlport_probe2_f_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_length(self)

    def history(self) -> "unsigned int":
        r"""history(ctrlport_probe2_f_sptr self) -> unsigned int"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(ctrlport_probe2_f_sptr self, int which, int delay)
        declare_sample_delay(ctrlport_probe2_f_sptr self, unsigned int delay)
        """
        return _blocks_swig0.ctrlport_probe2_f_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(ctrlport_probe2_f_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(ctrlport_probe2_f_sptr self, int multiple)"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(ctrlport_probe2_f_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(ctrlport_probe2_f_sptr self) -> double"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(ctrlport_probe2_f_sptr self) -> uint64_t"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(ctrlport_probe2_f_sptr self) -> uint64_t"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(ctrlport_probe2_f_sptr self) -> bool"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(ctrlport_probe2_f_sptr self) -> bool"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(ctrlport_probe2_f_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(ctrlport_probe2_f_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(ctrlport_probe2_f_sptr self, std::string level)"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(ctrlport_probe2_f_sptr self) -> std::string"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(ctrlport_probe2_f_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(ctrlport_probe2_f_sptr self, int m)"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(ctrlport_probe2_f_sptr self)"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(ctrlport_probe2_f_sptr self) -> bool"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(ctrlport_probe2_f_sptr self, int m)"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(ctrlport_probe2_f_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(ctrlport_probe2_f_sptr self, int i) -> long"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(ctrlport_probe2_f_sptr self, long max_output_buffer)
        set_max_output_buffer(ctrlport_probe2_f_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.ctrlport_probe2_f_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(ctrlport_probe2_f_sptr self, int i) -> long"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(ctrlport_probe2_f_sptr self, long min_output_buffer)
        set_min_output_buffer(ctrlport_probe2_f_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.ctrlport_probe2_f_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(ctrlport_probe2_f_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(ctrlport_probe2_f_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(ctrlport_probe2_f_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(ctrlport_probe2_f_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(ctrlport_probe2_f_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(ctrlport_probe2_f_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(ctrlport_probe2_f_sptr self, int which) -> float
        pc_input_buffers_full(ctrlport_probe2_f_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe2_f_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(ctrlport_probe2_f_sptr self, int which) -> float
        pc_input_buffers_full_avg(ctrlport_probe2_f_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe2_f_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(ctrlport_probe2_f_sptr self, int which) -> float
        pc_input_buffers_full_var(ctrlport_probe2_f_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe2_f_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(ctrlport_probe2_f_sptr self, int which) -> float
        pc_output_buffers_full(ctrlport_probe2_f_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe2_f_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(ctrlport_probe2_f_sptr self, int which) -> float
        pc_output_buffers_full_avg(ctrlport_probe2_f_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe2_f_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(ctrlport_probe2_f_sptr self, int which) -> float
        pc_output_buffers_full_var(ctrlport_probe2_f_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe2_f_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(ctrlport_probe2_f_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(ctrlport_probe2_f_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(ctrlport_probe2_f_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(ctrlport_probe2_f_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(ctrlport_probe2_f_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(ctrlport_probe2_f_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(ctrlport_probe2_f_sptr self)"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(ctrlport_probe2_f_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(ctrlport_probe2_f_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(ctrlport_probe2_f_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(ctrlport_probe2_f_sptr self, int priority) -> int"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(ctrlport_probe2_f_sptr self) -> std::string"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(ctrlport_probe2_f_sptr self) -> std::string"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(ctrlport_probe2_f_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(ctrlport_probe2_f_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(ctrlport_probe2_f_sptr self) -> long"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(ctrlport_probe2_f_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(ctrlport_probe2_f_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(ctrlport_probe2_f_sptr self) -> std::string"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(ctrlport_probe2_f_sptr self, std::string name)"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(ctrlport_probe2_f_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig0.ctrlport_probe2_f_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(ctrlport_probe2_f_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(ctrlport_probe2_f_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(ctrlport_probe2_f_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_message_subscribers(self, which_port)

# Register ctrlport_probe2_f_sptr in _blocks_swig0:
_blocks_swig0.ctrlport_probe2_f_sptr_swigregister(ctrlport_probe2_f_sptr)


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

class ctrlport_probe2_s_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::ctrlport_probe2_s > 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__(ctrlport_probe2_s_sptr self) -> ctrlport_probe2_s_sptr
        __init__(ctrlport_probe2_s_sptr self, ctrlport_probe2_s p) -> ctrlport_probe2_s_sptr
        """
        _blocks_swig0.ctrlport_probe2_s_sptr_swiginit(self, _blocks_swig0.new_ctrlport_probe2_s_sptr(*args))

    def __deref__(self) -> "gr::blocks::ctrlport_probe2_s *":
        r"""__deref__(ctrlport_probe2_s_sptr self) -> ctrlport_probe2_s"""
        return _blocks_swig0.ctrlport_probe2_s_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig0.delete_ctrlport_probe2_s_sptr

    def make(self, id: "std::string const &", desc: "std::string const &", len: "int", disp_mask: "unsigned int") -> "gr::blocks::ctrlport_probe2_s::sptr":
        r"""make(ctrlport_probe2_s_sptr self, std::string const & id, std::string const & desc, int len, unsigned int disp_mask) -> ctrlport_probe2_s_sptr"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_make(self, id, desc, len, disp_mask)

    def get(self) -> "std::vector< short,std::allocator< short > >":
        r"""get(ctrlport_probe2_s_sptr self) -> std::vector< short,std::allocator< short > >"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_get(self)

    def set_length(self, len: "int") -> "void":
        r"""set_length(ctrlport_probe2_s_sptr self, int len)"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_set_length(self, len)

    def length(self) -> "int":
        r"""length(ctrlport_probe2_s_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_length(self)

    def history(self) -> "unsigned int":
        r"""history(ctrlport_probe2_s_sptr self) -> unsigned int"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(ctrlport_probe2_s_sptr self, int which, int delay)
        declare_sample_delay(ctrlport_probe2_s_sptr self, unsigned int delay)
        """
        return _blocks_swig0.ctrlport_probe2_s_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(ctrlport_probe2_s_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(ctrlport_probe2_s_sptr self, int multiple)"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(ctrlport_probe2_s_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(ctrlport_probe2_s_sptr self) -> double"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(ctrlport_probe2_s_sptr self) -> uint64_t"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(ctrlport_probe2_s_sptr self) -> uint64_t"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(ctrlport_probe2_s_sptr self) -> bool"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(ctrlport_probe2_s_sptr self) -> bool"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(ctrlport_probe2_s_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(ctrlport_probe2_s_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(ctrlport_probe2_s_sptr self, std::string level)"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(ctrlport_probe2_s_sptr self) -> std::string"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(ctrlport_probe2_s_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(ctrlport_probe2_s_sptr self, int m)"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(ctrlport_probe2_s_sptr self)"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(ctrlport_probe2_s_sptr self) -> bool"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(ctrlport_probe2_s_sptr self, int m)"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(ctrlport_probe2_s_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(ctrlport_probe2_s_sptr self, int i) -> long"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(ctrlport_probe2_s_sptr self, long max_output_buffer)
        set_max_output_buffer(ctrlport_probe2_s_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.ctrlport_probe2_s_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(ctrlport_probe2_s_sptr self, int i) -> long"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(ctrlport_probe2_s_sptr self, long min_output_buffer)
        set_min_output_buffer(ctrlport_probe2_s_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.ctrlport_probe2_s_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(ctrlport_probe2_s_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(ctrlport_probe2_s_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(ctrlport_probe2_s_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(ctrlport_probe2_s_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(ctrlport_probe2_s_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(ctrlport_probe2_s_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(ctrlport_probe2_s_sptr self, int which) -> float
        pc_input_buffers_full(ctrlport_probe2_s_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe2_s_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(ctrlport_probe2_s_sptr self, int which) -> float
        pc_input_buffers_full_avg(ctrlport_probe2_s_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe2_s_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(ctrlport_probe2_s_sptr self, int which) -> float
        pc_input_buffers_full_var(ctrlport_probe2_s_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe2_s_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(ctrlport_probe2_s_sptr self, int which) -> float
        pc_output_buffers_full(ctrlport_probe2_s_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe2_s_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(ctrlport_probe2_s_sptr self, int which) -> float
        pc_output_buffers_full_avg(ctrlport_probe2_s_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe2_s_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(ctrlport_probe2_s_sptr self, int which) -> float
        pc_output_buffers_full_var(ctrlport_probe2_s_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe2_s_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(ctrlport_probe2_s_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(ctrlport_probe2_s_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(ctrlport_probe2_s_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(ctrlport_probe2_s_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(ctrlport_probe2_s_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(ctrlport_probe2_s_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(ctrlport_probe2_s_sptr self)"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(ctrlport_probe2_s_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(ctrlport_probe2_s_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(ctrlport_probe2_s_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(ctrlport_probe2_s_sptr self, int priority) -> int"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(ctrlport_probe2_s_sptr self) -> std::string"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(ctrlport_probe2_s_sptr self) -> std::string"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(ctrlport_probe2_s_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(ctrlport_probe2_s_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(ctrlport_probe2_s_sptr self) -> long"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(ctrlport_probe2_s_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(ctrlport_probe2_s_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(ctrlport_probe2_s_sptr self) -> std::string"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(ctrlport_probe2_s_sptr self, std::string name)"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(ctrlport_probe2_s_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig0.ctrlport_probe2_s_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(ctrlport_probe2_s_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(ctrlport_probe2_s_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(ctrlport_probe2_s_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_message_subscribers(self, which_port)

# Register ctrlport_probe2_s_sptr in _blocks_swig0:
_blocks_swig0.ctrlport_probe2_s_sptr_swigregister(ctrlport_probe2_s_sptr)


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

class ctrlport_probe2_i_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::ctrlport_probe2_i > 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__(ctrlport_probe2_i_sptr self) -> ctrlport_probe2_i_sptr
        __init__(ctrlport_probe2_i_sptr self, ctrlport_probe2_i p) -> ctrlport_probe2_i_sptr
        """
        _blocks_swig0.ctrlport_probe2_i_sptr_swiginit(self, _blocks_swig0.new_ctrlport_probe2_i_sptr(*args))

    def __deref__(self) -> "gr::blocks::ctrlport_probe2_i *":
        r"""__deref__(ctrlport_probe2_i_sptr self) -> ctrlport_probe2_i"""
        return _blocks_swig0.ctrlport_probe2_i_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig0.delete_ctrlport_probe2_i_sptr

    def make(self, id: "std::string const &", desc: "std::string const &", len: "int", disp_mask: "unsigned int") -> "gr::blocks::ctrlport_probe2_i::sptr":
        r"""make(ctrlport_probe2_i_sptr self, std::string const & id, std::string const & desc, int len, unsigned int disp_mask) -> ctrlport_probe2_i_sptr"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_make(self, id, desc, len, disp_mask)

    def get(self) -> "std::vector< int,std::allocator< int > >":
        r"""get(ctrlport_probe2_i_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_get(self)

    def set_length(self, len: "int") -> "void":
        r"""set_length(ctrlport_probe2_i_sptr self, int len)"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_set_length(self, len)

    def length(self) -> "int":
        r"""length(ctrlport_probe2_i_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_length(self)

    def history(self) -> "unsigned int":
        r"""history(ctrlport_probe2_i_sptr self) -> unsigned int"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(ctrlport_probe2_i_sptr self, int which, int delay)
        declare_sample_delay(ctrlport_probe2_i_sptr self, unsigned int delay)
        """
        return _blocks_swig0.ctrlport_probe2_i_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(ctrlport_probe2_i_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(ctrlport_probe2_i_sptr self, int multiple)"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(ctrlport_probe2_i_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(ctrlport_probe2_i_sptr self) -> double"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(ctrlport_probe2_i_sptr self) -> uint64_t"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(ctrlport_probe2_i_sptr self) -> uint64_t"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(ctrlport_probe2_i_sptr self) -> bool"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(ctrlport_probe2_i_sptr self) -> bool"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(ctrlport_probe2_i_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(ctrlport_probe2_i_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(ctrlport_probe2_i_sptr self, std::string level)"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(ctrlport_probe2_i_sptr self) -> std::string"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(ctrlport_probe2_i_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(ctrlport_probe2_i_sptr self, int m)"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(ctrlport_probe2_i_sptr self)"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(ctrlport_probe2_i_sptr self) -> bool"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(ctrlport_probe2_i_sptr self, int m)"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(ctrlport_probe2_i_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(ctrlport_probe2_i_sptr self, int i) -> long"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(ctrlport_probe2_i_sptr self, long max_output_buffer)
        set_max_output_buffer(ctrlport_probe2_i_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.ctrlport_probe2_i_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(ctrlport_probe2_i_sptr self, int i) -> long"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(ctrlport_probe2_i_sptr self, long min_output_buffer)
        set_min_output_buffer(ctrlport_probe2_i_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.ctrlport_probe2_i_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(ctrlport_probe2_i_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(ctrlport_probe2_i_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(ctrlport_probe2_i_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(ctrlport_probe2_i_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(ctrlport_probe2_i_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(ctrlport_probe2_i_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(ctrlport_probe2_i_sptr self, int which) -> float
        pc_input_buffers_full(ctrlport_probe2_i_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe2_i_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(ctrlport_probe2_i_sptr self, int which) -> float
        pc_input_buffers_full_avg(ctrlport_probe2_i_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe2_i_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(ctrlport_probe2_i_sptr self, int which) -> float
        pc_input_buffers_full_var(ctrlport_probe2_i_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe2_i_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(ctrlport_probe2_i_sptr self, int which) -> float
        pc_output_buffers_full(ctrlport_probe2_i_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe2_i_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(ctrlport_probe2_i_sptr self, int which) -> float
        pc_output_buffers_full_avg(ctrlport_probe2_i_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe2_i_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(ctrlport_probe2_i_sptr self, int which) -> float
        pc_output_buffers_full_var(ctrlport_probe2_i_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe2_i_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(ctrlport_probe2_i_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(ctrlport_probe2_i_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(ctrlport_probe2_i_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(ctrlport_probe2_i_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(ctrlport_probe2_i_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(ctrlport_probe2_i_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(ctrlport_probe2_i_sptr self)"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(ctrlport_probe2_i_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(ctrlport_probe2_i_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(ctrlport_probe2_i_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(ctrlport_probe2_i_sptr self, int priority) -> int"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(ctrlport_probe2_i_sptr self) -> std::string"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(ctrlport_probe2_i_sptr self) -> std::string"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(ctrlport_probe2_i_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(ctrlport_probe2_i_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(ctrlport_probe2_i_sptr self) -> long"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(ctrlport_probe2_i_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(ctrlport_probe2_i_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(ctrlport_probe2_i_sptr self) -> std::string"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(ctrlport_probe2_i_sptr self, std::string name)"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(ctrlport_probe2_i_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig0.ctrlport_probe2_i_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(ctrlport_probe2_i_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(ctrlport_probe2_i_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(ctrlport_probe2_i_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_message_subscribers(self, which_port)

# Register ctrlport_probe2_i_sptr in _blocks_swig0:
_blocks_swig0.ctrlport_probe2_i_sptr_swigregister(ctrlport_probe2_i_sptr)


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

class ctrlport_probe2_b_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::ctrlport_probe2_b > 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__(ctrlport_probe2_b_sptr self) -> ctrlport_probe2_b_sptr
        __init__(ctrlport_probe2_b_sptr self, ctrlport_probe2_b p) -> ctrlport_probe2_b_sptr
        """
        _blocks_swig0.ctrlport_probe2_b_sptr_swiginit(self, _blocks_swig0.new_ctrlport_probe2_b_sptr(*args))

    def __deref__(self) -> "gr::blocks::ctrlport_probe2_b *":
        r"""__deref__(ctrlport_probe2_b_sptr self) -> ctrlport_probe2_b"""
        return _blocks_swig0.ctrlport_probe2_b_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig0.delete_ctrlport_probe2_b_sptr

    def make(self, id: "std::string const &", desc: "std::string const &", len: "int", disp_mask: "unsigned int") -> "gr::blocks::ctrlport_probe2_b::sptr":
        r"""make(ctrlport_probe2_b_sptr self, std::string const & id, std::string const & desc, int len, unsigned int disp_mask) -> ctrlport_probe2_b_sptr"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_make(self, id, desc, len, disp_mask)

    def get(self) -> "std::vector< signed char,std::allocator< signed char > >":
        r"""get(ctrlport_probe2_b_sptr self) -> std::vector< signed char,std::allocator< signed char > >"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_get(self)

    def set_length(self, len: "int") -> "void":
        r"""set_length(ctrlport_probe2_b_sptr self, int len)"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_set_length(self, len)

    def length(self) -> "int":
        r"""length(ctrlport_probe2_b_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_length(self)

    def history(self) -> "unsigned int":
        r"""history(ctrlport_probe2_b_sptr self) -> unsigned int"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(ctrlport_probe2_b_sptr self, int which, int delay)
        declare_sample_delay(ctrlport_probe2_b_sptr self, unsigned int delay)
        """
        return _blocks_swig0.ctrlport_probe2_b_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(ctrlport_probe2_b_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(ctrlport_probe2_b_sptr self, int multiple)"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(ctrlport_probe2_b_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(ctrlport_probe2_b_sptr self) -> double"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(ctrlport_probe2_b_sptr self) -> uint64_t"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(ctrlport_probe2_b_sptr self) -> uint64_t"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(ctrlport_probe2_b_sptr self) -> bool"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(ctrlport_probe2_b_sptr self) -> bool"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(ctrlport_probe2_b_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(ctrlport_probe2_b_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(ctrlport_probe2_b_sptr self, std::string level)"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(ctrlport_probe2_b_sptr self) -> std::string"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(ctrlport_probe2_b_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(ctrlport_probe2_b_sptr self, int m)"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(ctrlport_probe2_b_sptr self)"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(ctrlport_probe2_b_sptr self) -> bool"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(ctrlport_probe2_b_sptr self, int m)"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(ctrlport_probe2_b_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(ctrlport_probe2_b_sptr self, int i) -> long"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(ctrlport_probe2_b_sptr self, long max_output_buffer)
        set_max_output_buffer(ctrlport_probe2_b_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.ctrlport_probe2_b_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(ctrlport_probe2_b_sptr self, int i) -> long"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(ctrlport_probe2_b_sptr self, long min_output_buffer)
        set_min_output_buffer(ctrlport_probe2_b_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.ctrlport_probe2_b_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(ctrlport_probe2_b_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(ctrlport_probe2_b_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(ctrlport_probe2_b_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(ctrlport_probe2_b_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(ctrlport_probe2_b_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(ctrlport_probe2_b_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(ctrlport_probe2_b_sptr self, int which) -> float
        pc_input_buffers_full(ctrlport_probe2_b_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe2_b_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(ctrlport_probe2_b_sptr self, int which) -> float
        pc_input_buffers_full_avg(ctrlport_probe2_b_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe2_b_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(ctrlport_probe2_b_sptr self, int which) -> float
        pc_input_buffers_full_var(ctrlport_probe2_b_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe2_b_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(ctrlport_probe2_b_sptr self, int which) -> float
        pc_output_buffers_full(ctrlport_probe2_b_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe2_b_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(ctrlport_probe2_b_sptr self, int which) -> float
        pc_output_buffers_full_avg(ctrlport_probe2_b_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe2_b_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(ctrlport_probe2_b_sptr self, int which) -> float
        pc_output_buffers_full_var(ctrlport_probe2_b_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe2_b_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(ctrlport_probe2_b_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(ctrlport_probe2_b_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(ctrlport_probe2_b_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(ctrlport_probe2_b_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(ctrlport_probe2_b_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(ctrlport_probe2_b_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(ctrlport_probe2_b_sptr self)"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(ctrlport_probe2_b_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(ctrlport_probe2_b_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(ctrlport_probe2_b_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(ctrlport_probe2_b_sptr self, int priority) -> int"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(ctrlport_probe2_b_sptr self) -> std::string"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(ctrlport_probe2_b_sptr self) -> std::string"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(ctrlport_probe2_b_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(ctrlport_probe2_b_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(ctrlport_probe2_b_sptr self) -> long"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(ctrlport_probe2_b_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(ctrlport_probe2_b_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(ctrlport_probe2_b_sptr self) -> std::string"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(ctrlport_probe2_b_sptr self, std::string name)"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(ctrlport_probe2_b_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig0.ctrlport_probe2_b_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(ctrlport_probe2_b_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(ctrlport_probe2_b_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(ctrlport_probe2_b_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_message_subscribers(self, which_port)

# Register ctrlport_probe2_b_sptr in _blocks_swig0:
_blocks_swig0.ctrlport_probe2_b_sptr_swigregister(ctrlport_probe2_b_sptr)


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



