# 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_swig7
else:
    import _blocks_swig7

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_swig7.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_swig7.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_swig7.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_swig7.high_res_timer_epoch()
class deinterleave(object):
    r"""Proxy of C++ gr::blocks::deinterleave 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", blocksize: "unsigned int"=1) -> "gr::blocks::deinterleave::sptr":
        r"""make(size_t itemsize, unsigned int blocksize=1) -> deinterleave_sptr"""
        return _blocks_swig7.deinterleave_make(itemsize, blocksize)
    __swig_destroy__ = _blocks_swig7.delete_deinterleave

# Register deinterleave in _blocks_swig7:
_blocks_swig7.deinterleave_swigregister(deinterleave)

def deinterleave_make(itemsize: "size_t", blocksize: "unsigned int"=1) -> "gr::blocks::deinterleave::sptr":
    r"""deinterleave_make(size_t itemsize, unsigned int blocksize=1) -> deinterleave_sptr"""
    return _blocks_swig7.deinterleave_make(itemsize, blocksize)

class exponentiate_const_cci(object):
    r"""Proxy of C++ gr::blocks::exponentiate_const_cci 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(exponent: "int", vlen: "size_t"=1) -> "gr::blocks::exponentiate_const_cci::sptr":
        r"""make(int exponent, size_t vlen=1) -> exponentiate_const_cci_sptr"""
        return _blocks_swig7.exponentiate_const_cci_make(exponent, vlen)

    def set_exponent(self, exponent: "int") -> "void":
        r"""set_exponent(exponentiate_const_cci self, int exponent)"""
        return _blocks_swig7.exponentiate_const_cci_set_exponent(self, exponent)
    __swig_destroy__ = _blocks_swig7.delete_exponentiate_const_cci

# Register exponentiate_const_cci in _blocks_swig7:
_blocks_swig7.exponentiate_const_cci_swigregister(exponentiate_const_cci)

def exponentiate_const_cci_make(exponent: "int", vlen: "size_t"=1) -> "gr::blocks::exponentiate_const_cci::sptr":
    r"""exponentiate_const_cci_make(int exponent, size_t vlen=1) -> exponentiate_const_cci_sptr"""
    return _blocks_swig7.exponentiate_const_cci_make(exponent, vlen)

class selector(object):
    r"""Proxy of C++ gr::blocks::selector 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", input_index: "unsigned int", output_index: "unsigned int") -> "gr::blocks::selector::sptr":
        r"""make(size_t itemsize, unsigned int input_index, unsigned int output_index) -> selector_sptr"""
        return _blocks_swig7.selector_make(itemsize, input_index, output_index)

    def set_enabled(self, enable: "bool") -> "void":
        r"""set_enabled(selector self, bool enable)"""
        return _blocks_swig7.selector_set_enabled(self, enable)

    def enabled(self) -> "bool":
        r"""enabled(selector self) -> bool"""
        return _blocks_swig7.selector_enabled(self)

    def set_input_index(self, input_index: "unsigned int") -> "void":
        r"""set_input_index(selector self, unsigned int input_index)"""
        return _blocks_swig7.selector_set_input_index(self, input_index)

    def input_index(self) -> "int":
        r"""input_index(selector self) -> int"""
        return _blocks_swig7.selector_input_index(self)

    def set_output_index(self, output_index: "unsigned int") -> "void":
        r"""set_output_index(selector self, unsigned int output_index)"""
        return _blocks_swig7.selector_set_output_index(self, output_index)

    def output_index(self) -> "int":
        r"""output_index(selector self) -> int"""
        return _blocks_swig7.selector_output_index(self)
    __swig_destroy__ = _blocks_swig7.delete_selector

# Register selector in _blocks_swig7:
_blocks_swig7.selector_swigregister(selector)

def selector_make(itemsize: "size_t", input_index: "unsigned int", output_index: "unsigned int") -> "gr::blocks::selector::sptr":
    r"""selector_make(size_t itemsize, unsigned int input_index, unsigned int output_index) -> selector_sptr"""
    return _blocks_swig7.selector_make(itemsize, input_index, output_index)

class skiphead(object):
    r"""Proxy of C++ gr::blocks::skiphead 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", nitems_to_skip: "uint64_t") -> "gr::blocks::skiphead::sptr":
        r"""make(size_t itemsize, uint64_t nitems_to_skip) -> skiphead_sptr"""
        return _blocks_swig7.skiphead_make(itemsize, nitems_to_skip)
    __swig_destroy__ = _blocks_swig7.delete_skiphead

# Register skiphead in _blocks_swig7:
_blocks_swig7.skiphead_swigregister(skiphead)

def skiphead_make(itemsize: "size_t", nitems_to_skip: "uint64_t") -> "gr::blocks::skiphead::sptr":
    r"""skiphead_make(size_t itemsize, uint64_t nitems_to_skip) -> skiphead_sptr"""
    return _blocks_swig7.skiphead_make(itemsize, nitems_to_skip)

class stream_mux(object):
    r"""Proxy of C++ gr::blocks::stream_mux 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", lengths: "std::vector< int,std::allocator< int > > const &") -> "gr::blocks::stream_mux::sptr":
        r"""make(size_t itemsize, std::vector< int,std::allocator< int > > const & lengths) -> stream_mux_sptr"""
        return _blocks_swig7.stream_mux_make(itemsize, lengths)
    __swig_destroy__ = _blocks_swig7.delete_stream_mux

# Register stream_mux in _blocks_swig7:
_blocks_swig7.stream_mux_swigregister(stream_mux)

def stream_mux_make(itemsize: "size_t", lengths: "std::vector< int,std::allocator< int > > const &") -> "gr::blocks::stream_mux::sptr":
    r"""stream_mux_make(size_t itemsize, std::vector< int,std::allocator< int > > const & lengths) -> stream_mux_sptr"""
    return _blocks_swig7.stream_mux_make(itemsize, lengths)

class stream_to_streams(object):
    r"""Proxy of C++ gr::blocks::stream_to_streams 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", nstreams: "size_t") -> "gr::blocks::stream_to_streams::sptr":
        r"""make(size_t itemsize, size_t nstreams) -> stream_to_streams_sptr"""
        return _blocks_swig7.stream_to_streams_make(itemsize, nstreams)
    __swig_destroy__ = _blocks_swig7.delete_stream_to_streams

# Register stream_to_streams in _blocks_swig7:
_blocks_swig7.stream_to_streams_swigregister(stream_to_streams)

def stream_to_streams_make(itemsize: "size_t", nstreams: "size_t") -> "gr::blocks::stream_to_streams::sptr":
    r"""stream_to_streams_make(size_t itemsize, size_t nstreams) -> stream_to_streams_sptr"""
    return _blocks_swig7.stream_to_streams_make(itemsize, nstreams)

class stream_to_tagged_stream(object):
    r"""Proxy of C++ gr::blocks::stream_to_tagged_stream 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", vlen: "unsigned int", packet_len: "unsigned int", len_tag_key: "std::string const &") -> "gr::blocks::stream_to_tagged_stream::sptr":
        r"""make(size_t itemsize, unsigned int vlen, unsigned int packet_len, std::string const & len_tag_key) -> stream_to_tagged_stream_sptr"""
        return _blocks_swig7.stream_to_tagged_stream_make(itemsize, vlen, packet_len, len_tag_key)

    def set_packet_len(self, packet_len: "unsigned int") -> "void":
        r"""set_packet_len(stream_to_tagged_stream self, unsigned int packet_len)"""
        return _blocks_swig7.stream_to_tagged_stream_set_packet_len(self, packet_len)

    def set_packet_len_pmt(self, packet_len: "unsigned int") -> "void":
        r"""set_packet_len_pmt(stream_to_tagged_stream self, unsigned int packet_len)"""
        return _blocks_swig7.stream_to_tagged_stream_set_packet_len_pmt(self, packet_len)
    __swig_destroy__ = _blocks_swig7.delete_stream_to_tagged_stream

# Register stream_to_tagged_stream in _blocks_swig7:
_blocks_swig7.stream_to_tagged_stream_swigregister(stream_to_tagged_stream)

def stream_to_tagged_stream_make(itemsize: "size_t", vlen: "unsigned int", packet_len: "unsigned int", len_tag_key: "std::string const &") -> "gr::blocks::stream_to_tagged_stream::sptr":
    r"""stream_to_tagged_stream_make(size_t itemsize, unsigned int vlen, unsigned int packet_len, std::string const & len_tag_key) -> stream_to_tagged_stream_sptr"""
    return _blocks_swig7.stream_to_tagged_stream_make(itemsize, vlen, packet_len, len_tag_key)

class stream_to_vector(object):
    r"""Proxy of C++ gr::blocks::stream_to_vector 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", nitems_per_block: "size_t") -> "gr::blocks::stream_to_vector::sptr":
        r"""make(size_t itemsize, size_t nitems_per_block) -> stream_to_vector_sptr"""
        return _blocks_swig7.stream_to_vector_make(itemsize, nitems_per_block)
    __swig_destroy__ = _blocks_swig7.delete_stream_to_vector

# Register stream_to_vector in _blocks_swig7:
_blocks_swig7.stream_to_vector_swigregister(stream_to_vector)

def stream_to_vector_make(itemsize: "size_t", nitems_per_block: "size_t") -> "gr::blocks::stream_to_vector::sptr":
    r"""stream_to_vector_make(size_t itemsize, size_t nitems_per_block) -> stream_to_vector_sptr"""
    return _blocks_swig7.stream_to_vector_make(itemsize, nitems_per_block)

class streams_to_stream(object):
    r"""Proxy of C++ gr::blocks::streams_to_stream 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", nstreams: "size_t") -> "gr::blocks::streams_to_stream::sptr":
        r"""make(size_t itemsize, size_t nstreams) -> streams_to_stream_sptr"""
        return _blocks_swig7.streams_to_stream_make(itemsize, nstreams)
    __swig_destroy__ = _blocks_swig7.delete_streams_to_stream

# Register streams_to_stream in _blocks_swig7:
_blocks_swig7.streams_to_stream_swigregister(streams_to_stream)

def streams_to_stream_make(itemsize: "size_t", nstreams: "size_t") -> "gr::blocks::streams_to_stream::sptr":
    r"""streams_to_stream_make(size_t itemsize, size_t nstreams) -> streams_to_stream_sptr"""
    return _blocks_swig7.streams_to_stream_make(itemsize, nstreams)

class streams_to_vector(object):
    r"""Proxy of C++ gr::blocks::streams_to_vector 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", nstreams: "size_t") -> "gr::blocks::streams_to_vector::sptr":
        r"""make(size_t itemsize, size_t nstreams) -> streams_to_vector_sptr"""
        return _blocks_swig7.streams_to_vector_make(itemsize, nstreams)
    __swig_destroy__ = _blocks_swig7.delete_streams_to_vector

# Register streams_to_vector in _blocks_swig7:
_blocks_swig7.streams_to_vector_swigregister(streams_to_vector)

def streams_to_vector_make(itemsize: "size_t", nstreams: "size_t") -> "gr::blocks::streams_to_vector::sptr":
    r"""streams_to_vector_make(size_t itemsize, size_t nstreams) -> streams_to_vector_sptr"""
    return _blocks_swig7.streams_to_vector_make(itemsize, nstreams)

class tag_debug(object):
    r"""Proxy of C++ gr::blocks::tag_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(*args, **kwargs) -> "gr::blocks::tag_debug::sptr":
        r"""make(size_t sizeof_stream_item, std::string const & name, std::string const & key_filter="") -> tag_debug_sptr"""
        return _blocks_swig7.tag_debug_make(*args, **kwargs)

    def current_tags(self) -> "std::vector< gr::tag_t,std::allocator< gr::tag_t > >":
        r"""current_tags(tag_debug self) -> tags_vector_t"""
        return _blocks_swig7.tag_debug_current_tags(self)

    def num_tags(self) -> "int":
        r"""num_tags(tag_debug self) -> int"""
        return _blocks_swig7.tag_debug_num_tags(self)

    def set_display(self, d: "bool") -> "void":
        r"""set_display(tag_debug self, bool d)"""
        return _blocks_swig7.tag_debug_set_display(self, d)

    def set_key_filter(self, key_filter: "std::string const &") -> "void":
        r"""set_key_filter(tag_debug self, std::string const & key_filter)"""
        return _blocks_swig7.tag_debug_set_key_filter(self, key_filter)

    def key_filter(self) -> "std::string":
        r"""key_filter(tag_debug self) -> std::string"""
        return _blocks_swig7.tag_debug_key_filter(self)
    __swig_destroy__ = _blocks_swig7.delete_tag_debug

# Register tag_debug in _blocks_swig7:
_blocks_swig7.tag_debug_swigregister(tag_debug)

def tag_debug_make(*args, **kwargs) -> "gr::blocks::tag_debug::sptr":
    r"""tag_debug_make(size_t sizeof_stream_item, std::string const & name, std::string const & key_filter="") -> tag_debug_sptr"""
    return _blocks_swig7.tag_debug_make(*args, **kwargs)

class tagged_file_sink(object):
    r"""Proxy of C++ gr::blocks::tagged_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", samp_rate: "double") -> "gr::blocks::tagged_file_sink::sptr":
        r"""make(size_t itemsize, double samp_rate) -> tagged_file_sink_sptr"""
        return _blocks_swig7.tagged_file_sink_make(itemsize, samp_rate)
    __swig_destroy__ = _blocks_swig7.delete_tagged_file_sink

# Register tagged_file_sink in _blocks_swig7:
_blocks_swig7.tagged_file_sink_swigregister(tagged_file_sink)

def tagged_file_sink_make(itemsize: "size_t", samp_rate: "double") -> "gr::blocks::tagged_file_sink::sptr":
    r"""tagged_file_sink_make(size_t itemsize, double samp_rate) -> tagged_file_sink_sptr"""
    return _blocks_swig7.tagged_file_sink_make(itemsize, samp_rate)

class throttle(object):
    r"""Proxy of C++ gr::blocks::throttle 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", samples_per_sec: "double", ignore_tags: "bool"=True) -> "gr::blocks::throttle::sptr":
        r"""make(size_t itemsize, double samples_per_sec, bool ignore_tags=True) -> throttle_sptr"""
        return _blocks_swig7.throttle_make(itemsize, samples_per_sec, ignore_tags)

    def set_sample_rate(self, rate: "double") -> "void":
        r"""set_sample_rate(throttle self, double rate)"""
        return _blocks_swig7.throttle_set_sample_rate(self, rate)

    def sample_rate(self) -> "double":
        r"""sample_rate(throttle self) -> double"""
        return _blocks_swig7.throttle_sample_rate(self)
    __swig_destroy__ = _blocks_swig7.delete_throttle

# Register throttle in _blocks_swig7:
_blocks_swig7.throttle_swigregister(throttle)

def throttle_make(itemsize: "size_t", samples_per_sec: "double", ignore_tags: "bool"=True) -> "gr::blocks::throttle::sptr":
    r"""throttle_make(size_t itemsize, double samples_per_sec, bool ignore_tags=True) -> throttle_sptr"""
    return _blocks_swig7.throttle_make(itemsize, samples_per_sec, ignore_tags)

class deinterleave_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::deinterleave > 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__(deinterleave_sptr self) -> deinterleave_sptr
        __init__(deinterleave_sptr self, deinterleave p) -> deinterleave_sptr
        """
        _blocks_swig7.deinterleave_sptr_swiginit(self, _blocks_swig7.new_deinterleave_sptr(*args))

    def __deref__(self) -> "gr::blocks::deinterleave *":
        r"""__deref__(deinterleave_sptr self) -> deinterleave"""
        return _blocks_swig7.deinterleave_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig7.delete_deinterleave_sptr

    def make(self, itemsize: "size_t", blocksize: "unsigned int"=1) -> "gr::blocks::deinterleave::sptr":
        r"""make(deinterleave_sptr self, size_t itemsize, unsigned int blocksize=1) -> deinterleave_sptr"""
        return _blocks_swig7.deinterleave_sptr_make(self, itemsize, blocksize)

    def history(self) -> "unsigned int":
        r"""history(deinterleave_sptr self) -> unsigned int"""
        return _blocks_swig7.deinterleave_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(deinterleave_sptr self, int which, int delay)
        declare_sample_delay(deinterleave_sptr self, unsigned int delay)
        """
        return _blocks_swig7.deinterleave_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(deinterleave_sptr self, int which) -> unsigned int"""
        return _blocks_swig7.deinterleave_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(deinterleave_sptr self, int multiple)"""
        return _blocks_swig7.deinterleave_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(deinterleave_sptr self) -> int"""
        return _blocks_swig7.deinterleave_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(deinterleave_sptr self) -> double"""
        return _blocks_swig7.deinterleave_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(deinterleave_sptr self) -> uint64_t"""
        return _blocks_swig7.deinterleave_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(deinterleave_sptr self) -> uint64_t"""
        return _blocks_swig7.deinterleave_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(deinterleave_sptr self) -> bool"""
        return _blocks_swig7.deinterleave_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(deinterleave_sptr self) -> bool"""
        return _blocks_swig7.deinterleave_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(deinterleave_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig7.deinterleave_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(deinterleave_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig7.deinterleave_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(deinterleave_sptr self, std::string level)"""
        return _blocks_swig7.deinterleave_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(deinterleave_sptr self) -> std::string"""
        return _blocks_swig7.deinterleave_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(deinterleave_sptr self) -> int"""
        return _blocks_swig7.deinterleave_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(deinterleave_sptr self, int m)"""
        return _blocks_swig7.deinterleave_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(deinterleave_sptr self)"""
        return _blocks_swig7.deinterleave_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(deinterleave_sptr self) -> bool"""
        return _blocks_swig7.deinterleave_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(deinterleave_sptr self, int m)"""
        return _blocks_swig7.deinterleave_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(deinterleave_sptr self) -> int"""
        return _blocks_swig7.deinterleave_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(deinterleave_sptr self, int i) -> long"""
        return _blocks_swig7.deinterleave_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(deinterleave_sptr self, long max_output_buffer)
        set_max_output_buffer(deinterleave_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig7.deinterleave_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(deinterleave_sptr self, int i) -> long"""
        return _blocks_swig7.deinterleave_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(deinterleave_sptr self, long min_output_buffer)
        set_min_output_buffer(deinterleave_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig7.deinterleave_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(deinterleave_sptr self) -> float"""
        return _blocks_swig7.deinterleave_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(deinterleave_sptr self) -> float"""
        return _blocks_swig7.deinterleave_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(deinterleave_sptr self) -> float"""
        return _blocks_swig7.deinterleave_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(deinterleave_sptr self) -> float"""
        return _blocks_swig7.deinterleave_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(deinterleave_sptr self) -> float"""
        return _blocks_swig7.deinterleave_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(deinterleave_sptr self) -> float"""
        return _blocks_swig7.deinterleave_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(deinterleave_sptr self, int which) -> float
        pc_input_buffers_full(deinterleave_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.deinterleave_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(deinterleave_sptr self, int which) -> float
        pc_input_buffers_full_avg(deinterleave_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.deinterleave_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(deinterleave_sptr self, int which) -> float
        pc_input_buffers_full_var(deinterleave_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.deinterleave_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(deinterleave_sptr self, int which) -> float
        pc_output_buffers_full(deinterleave_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.deinterleave_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(deinterleave_sptr self, int which) -> float
        pc_output_buffers_full_avg(deinterleave_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.deinterleave_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(deinterleave_sptr self, int which) -> float
        pc_output_buffers_full_var(deinterleave_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.deinterleave_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(deinterleave_sptr self) -> float"""
        return _blocks_swig7.deinterleave_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(deinterleave_sptr self) -> float"""
        return _blocks_swig7.deinterleave_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(deinterleave_sptr self) -> float"""
        return _blocks_swig7.deinterleave_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(deinterleave_sptr self) -> float"""
        return _blocks_swig7.deinterleave_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(deinterleave_sptr self) -> float"""
        return _blocks_swig7.deinterleave_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(deinterleave_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig7.deinterleave_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(deinterleave_sptr self)"""
        return _blocks_swig7.deinterleave_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(deinterleave_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig7.deinterleave_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(deinterleave_sptr self) -> int"""
        return _blocks_swig7.deinterleave_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(deinterleave_sptr self) -> int"""
        return _blocks_swig7.deinterleave_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(deinterleave_sptr self, int priority) -> int"""
        return _blocks_swig7.deinterleave_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(deinterleave_sptr self) -> std::string"""
        return _blocks_swig7.deinterleave_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(deinterleave_sptr self) -> std::string"""
        return _blocks_swig7.deinterleave_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(deinterleave_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.deinterleave_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(deinterleave_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.deinterleave_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(deinterleave_sptr self) -> long"""
        return _blocks_swig7.deinterleave_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(deinterleave_sptr self) -> basic_block_sptr"""
        return _blocks_swig7.deinterleave_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(deinterleave_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig7.deinterleave_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(deinterleave_sptr self) -> std::string"""
        return _blocks_swig7.deinterleave_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(deinterleave_sptr self, std::string name)"""
        return _blocks_swig7.deinterleave_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(deinterleave_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig7.deinterleave_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(deinterleave_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig7.deinterleave_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(deinterleave_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig7.deinterleave_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(deinterleave_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig7.deinterleave_sptr_message_subscribers(self, which_port)

# Register deinterleave_sptr in _blocks_swig7:
_blocks_swig7.deinterleave_sptr_swigregister(deinterleave_sptr)


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

class divide_ff(object):
    r"""Proxy of C++ gr::blocks::divide< float > 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(vlen: "size_t"=1) -> "gr::blocks::divide< float >::sptr":
        r"""make(size_t vlen=1) -> divide_ff_sptr"""
        return _blocks_swig7.divide_ff_make(vlen)
    __swig_destroy__ = _blocks_swig7.delete_divide_ff

# Register divide_ff in _blocks_swig7:
_blocks_swig7.divide_ff_swigregister(divide_ff)

def divide_ff_make(vlen: "size_t"=1) -> "gr::blocks::divide< float >::sptr":
    r"""divide_ff_make(size_t vlen=1) -> divide_ff_sptr"""
    return _blocks_swig7.divide_ff_make(vlen)

class divide_ff_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::divide< float > > 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__(divide_ff_sptr self) -> divide_ff_sptr
        __init__(divide_ff_sptr self, divide_ff p) -> divide_ff_sptr
        """
        _blocks_swig7.divide_ff_sptr_swiginit(self, _blocks_swig7.new_divide_ff_sptr(*args))

    def __deref__(self) -> "gr::blocks::divide< float > *":
        r"""__deref__(divide_ff_sptr self) -> divide_ff"""
        return _blocks_swig7.divide_ff_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig7.delete_divide_ff_sptr

    def make(self, vlen: "size_t"=1) -> "gr::blocks::divide< float >::sptr":
        r"""make(divide_ff_sptr self, size_t vlen=1) -> divide_ff_sptr"""
        return _blocks_swig7.divide_ff_sptr_make(self, vlen)

    def history(self) -> "unsigned int":
        r"""history(divide_ff_sptr self) -> unsigned int"""
        return _blocks_swig7.divide_ff_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(divide_ff_sptr self, int which, int delay)
        declare_sample_delay(divide_ff_sptr self, unsigned int delay)
        """
        return _blocks_swig7.divide_ff_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(divide_ff_sptr self, int which) -> unsigned int"""
        return _blocks_swig7.divide_ff_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(divide_ff_sptr self, int multiple)"""
        return _blocks_swig7.divide_ff_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(divide_ff_sptr self) -> int"""
        return _blocks_swig7.divide_ff_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(divide_ff_sptr self) -> double"""
        return _blocks_swig7.divide_ff_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(divide_ff_sptr self) -> uint64_t"""
        return _blocks_swig7.divide_ff_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(divide_ff_sptr self) -> uint64_t"""
        return _blocks_swig7.divide_ff_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(divide_ff_sptr self) -> bool"""
        return _blocks_swig7.divide_ff_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(divide_ff_sptr self) -> bool"""
        return _blocks_swig7.divide_ff_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(divide_ff_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig7.divide_ff_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(divide_ff_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig7.divide_ff_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(divide_ff_sptr self, std::string level)"""
        return _blocks_swig7.divide_ff_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(divide_ff_sptr self) -> std::string"""
        return _blocks_swig7.divide_ff_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(divide_ff_sptr self) -> int"""
        return _blocks_swig7.divide_ff_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(divide_ff_sptr self, int m)"""
        return _blocks_swig7.divide_ff_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(divide_ff_sptr self)"""
        return _blocks_swig7.divide_ff_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(divide_ff_sptr self) -> bool"""
        return _blocks_swig7.divide_ff_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(divide_ff_sptr self, int m)"""
        return _blocks_swig7.divide_ff_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(divide_ff_sptr self) -> int"""
        return _blocks_swig7.divide_ff_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(divide_ff_sptr self, int i) -> long"""
        return _blocks_swig7.divide_ff_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(divide_ff_sptr self, long max_output_buffer)
        set_max_output_buffer(divide_ff_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig7.divide_ff_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(divide_ff_sptr self, int i) -> long"""
        return _blocks_swig7.divide_ff_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(divide_ff_sptr self, long min_output_buffer)
        set_min_output_buffer(divide_ff_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig7.divide_ff_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(divide_ff_sptr self) -> float"""
        return _blocks_swig7.divide_ff_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(divide_ff_sptr self) -> float"""
        return _blocks_swig7.divide_ff_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(divide_ff_sptr self) -> float"""
        return _blocks_swig7.divide_ff_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(divide_ff_sptr self) -> float"""
        return _blocks_swig7.divide_ff_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(divide_ff_sptr self) -> float"""
        return _blocks_swig7.divide_ff_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(divide_ff_sptr self) -> float"""
        return _blocks_swig7.divide_ff_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(divide_ff_sptr self, int which) -> float
        pc_input_buffers_full(divide_ff_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.divide_ff_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(divide_ff_sptr self, int which) -> float
        pc_input_buffers_full_avg(divide_ff_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.divide_ff_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(divide_ff_sptr self, int which) -> float
        pc_input_buffers_full_var(divide_ff_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.divide_ff_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(divide_ff_sptr self, int which) -> float
        pc_output_buffers_full(divide_ff_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.divide_ff_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(divide_ff_sptr self, int which) -> float
        pc_output_buffers_full_avg(divide_ff_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.divide_ff_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(divide_ff_sptr self, int which) -> float
        pc_output_buffers_full_var(divide_ff_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.divide_ff_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(divide_ff_sptr self) -> float"""
        return _blocks_swig7.divide_ff_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(divide_ff_sptr self) -> float"""
        return _blocks_swig7.divide_ff_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(divide_ff_sptr self) -> float"""
        return _blocks_swig7.divide_ff_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(divide_ff_sptr self) -> float"""
        return _blocks_swig7.divide_ff_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(divide_ff_sptr self) -> float"""
        return _blocks_swig7.divide_ff_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(divide_ff_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig7.divide_ff_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(divide_ff_sptr self)"""
        return _blocks_swig7.divide_ff_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(divide_ff_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig7.divide_ff_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(divide_ff_sptr self) -> int"""
        return _blocks_swig7.divide_ff_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(divide_ff_sptr self) -> int"""
        return _blocks_swig7.divide_ff_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(divide_ff_sptr self, int priority) -> int"""
        return _blocks_swig7.divide_ff_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(divide_ff_sptr self) -> std::string"""
        return _blocks_swig7.divide_ff_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(divide_ff_sptr self) -> std::string"""
        return _blocks_swig7.divide_ff_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(divide_ff_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.divide_ff_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(divide_ff_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.divide_ff_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(divide_ff_sptr self) -> long"""
        return _blocks_swig7.divide_ff_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(divide_ff_sptr self) -> basic_block_sptr"""
        return _blocks_swig7.divide_ff_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(divide_ff_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig7.divide_ff_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(divide_ff_sptr self) -> std::string"""
        return _blocks_swig7.divide_ff_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(divide_ff_sptr self, std::string name)"""
        return _blocks_swig7.divide_ff_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(divide_ff_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig7.divide_ff_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(divide_ff_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig7.divide_ff_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(divide_ff_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig7.divide_ff_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(divide_ff_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig7.divide_ff_sptr_message_subscribers(self, which_port)

# Register divide_ff_sptr in _blocks_swig7:
_blocks_swig7.divide_ff_sptr_swigregister(divide_ff_sptr)


divide_ff_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
divide_ff = divide_ff.make

class divide_ss(object):
    r"""Proxy of C++ gr::blocks::divide< std::int16_t > 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(vlen: "size_t"=1) -> "gr::blocks::divide< short >::sptr":
        r"""make(size_t vlen=1) -> divide_ss_sptr"""
        return _blocks_swig7.divide_ss_make(vlen)
    __swig_destroy__ = _blocks_swig7.delete_divide_ss

# Register divide_ss in _blocks_swig7:
_blocks_swig7.divide_ss_swigregister(divide_ss)

def divide_ss_make(vlen: "size_t"=1) -> "gr::blocks::divide< short >::sptr":
    r"""divide_ss_make(size_t vlen=1) -> divide_ss_sptr"""
    return _blocks_swig7.divide_ss_make(vlen)

class divide_ss_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::divide< std::int16_t > > class."""

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

    def __init__(self, *args):
        r"""
        __init__(divide_ss_sptr self) -> divide_ss_sptr
        __init__(divide_ss_sptr self, divide_ss p) -> divide_ss_sptr
        """
        _blocks_swig7.divide_ss_sptr_swiginit(self, _blocks_swig7.new_divide_ss_sptr(*args))

    def __deref__(self) -> "gr::blocks::divide< std::int16_t > *":
        r"""__deref__(divide_ss_sptr self) -> divide_ss"""
        return _blocks_swig7.divide_ss_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig7.delete_divide_ss_sptr

    def make(self, vlen: "size_t"=1) -> "gr::blocks::divide< short >::sptr":
        r"""make(divide_ss_sptr self, size_t vlen=1) -> divide_ss_sptr"""
        return _blocks_swig7.divide_ss_sptr_make(self, vlen)

    def history(self) -> "unsigned int":
        r"""history(divide_ss_sptr self) -> unsigned int"""
        return _blocks_swig7.divide_ss_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(divide_ss_sptr self, int which, int delay)
        declare_sample_delay(divide_ss_sptr self, unsigned int delay)
        """
        return _blocks_swig7.divide_ss_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(divide_ss_sptr self, int which) -> unsigned int"""
        return _blocks_swig7.divide_ss_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(divide_ss_sptr self, int multiple)"""
        return _blocks_swig7.divide_ss_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(divide_ss_sptr self) -> int"""
        return _blocks_swig7.divide_ss_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(divide_ss_sptr self) -> double"""
        return _blocks_swig7.divide_ss_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(divide_ss_sptr self) -> uint64_t"""
        return _blocks_swig7.divide_ss_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(divide_ss_sptr self) -> uint64_t"""
        return _blocks_swig7.divide_ss_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(divide_ss_sptr self) -> bool"""
        return _blocks_swig7.divide_ss_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(divide_ss_sptr self) -> bool"""
        return _blocks_swig7.divide_ss_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(divide_ss_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig7.divide_ss_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(divide_ss_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig7.divide_ss_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(divide_ss_sptr self, std::string level)"""
        return _blocks_swig7.divide_ss_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(divide_ss_sptr self) -> std::string"""
        return _blocks_swig7.divide_ss_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(divide_ss_sptr self) -> int"""
        return _blocks_swig7.divide_ss_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(divide_ss_sptr self, int m)"""
        return _blocks_swig7.divide_ss_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(divide_ss_sptr self)"""
        return _blocks_swig7.divide_ss_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(divide_ss_sptr self) -> bool"""
        return _blocks_swig7.divide_ss_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(divide_ss_sptr self, int m)"""
        return _blocks_swig7.divide_ss_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(divide_ss_sptr self) -> int"""
        return _blocks_swig7.divide_ss_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(divide_ss_sptr self, int i) -> long"""
        return _blocks_swig7.divide_ss_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(divide_ss_sptr self, long max_output_buffer)
        set_max_output_buffer(divide_ss_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig7.divide_ss_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(divide_ss_sptr self, int i) -> long"""
        return _blocks_swig7.divide_ss_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(divide_ss_sptr self, long min_output_buffer)
        set_min_output_buffer(divide_ss_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig7.divide_ss_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(divide_ss_sptr self) -> float"""
        return _blocks_swig7.divide_ss_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(divide_ss_sptr self) -> float"""
        return _blocks_swig7.divide_ss_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(divide_ss_sptr self) -> float"""
        return _blocks_swig7.divide_ss_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(divide_ss_sptr self) -> float"""
        return _blocks_swig7.divide_ss_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(divide_ss_sptr self) -> float"""
        return _blocks_swig7.divide_ss_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(divide_ss_sptr self) -> float"""
        return _blocks_swig7.divide_ss_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(divide_ss_sptr self, int which) -> float
        pc_input_buffers_full(divide_ss_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.divide_ss_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(divide_ss_sptr self, int which) -> float
        pc_input_buffers_full_avg(divide_ss_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.divide_ss_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(divide_ss_sptr self, int which) -> float
        pc_input_buffers_full_var(divide_ss_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.divide_ss_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(divide_ss_sptr self, int which) -> float
        pc_output_buffers_full(divide_ss_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.divide_ss_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(divide_ss_sptr self, int which) -> float
        pc_output_buffers_full_avg(divide_ss_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.divide_ss_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(divide_ss_sptr self, int which) -> float
        pc_output_buffers_full_var(divide_ss_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.divide_ss_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(divide_ss_sptr self) -> float"""
        return _blocks_swig7.divide_ss_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(divide_ss_sptr self) -> float"""
        return _blocks_swig7.divide_ss_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(divide_ss_sptr self) -> float"""
        return _blocks_swig7.divide_ss_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(divide_ss_sptr self) -> float"""
        return _blocks_swig7.divide_ss_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(divide_ss_sptr self) -> float"""
        return _blocks_swig7.divide_ss_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(divide_ss_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig7.divide_ss_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(divide_ss_sptr self)"""
        return _blocks_swig7.divide_ss_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(divide_ss_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig7.divide_ss_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(divide_ss_sptr self) -> int"""
        return _blocks_swig7.divide_ss_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(divide_ss_sptr self) -> int"""
        return _blocks_swig7.divide_ss_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(divide_ss_sptr self, int priority) -> int"""
        return _blocks_swig7.divide_ss_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(divide_ss_sptr self) -> std::string"""
        return _blocks_swig7.divide_ss_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(divide_ss_sptr self) -> std::string"""
        return _blocks_swig7.divide_ss_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(divide_ss_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.divide_ss_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(divide_ss_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.divide_ss_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(divide_ss_sptr self) -> long"""
        return _blocks_swig7.divide_ss_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(divide_ss_sptr self) -> basic_block_sptr"""
        return _blocks_swig7.divide_ss_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(divide_ss_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig7.divide_ss_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(divide_ss_sptr self) -> std::string"""
        return _blocks_swig7.divide_ss_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(divide_ss_sptr self, std::string name)"""
        return _blocks_swig7.divide_ss_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(divide_ss_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig7.divide_ss_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(divide_ss_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig7.divide_ss_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(divide_ss_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig7.divide_ss_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(divide_ss_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig7.divide_ss_sptr_message_subscribers(self, which_port)

# Register divide_ss_sptr in _blocks_swig7:
_blocks_swig7.divide_ss_sptr_swigregister(divide_ss_sptr)


divide_ss_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
divide_ss = divide_ss.make

class divide_ii(object):
    r"""Proxy of C++ gr::blocks::divide< std::int32_t > 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(vlen: "size_t"=1) -> "gr::blocks::divide< int >::sptr":
        r"""make(size_t vlen=1) -> divide_ii_sptr"""
        return _blocks_swig7.divide_ii_make(vlen)
    __swig_destroy__ = _blocks_swig7.delete_divide_ii

# Register divide_ii in _blocks_swig7:
_blocks_swig7.divide_ii_swigregister(divide_ii)

def divide_ii_make(vlen: "size_t"=1) -> "gr::blocks::divide< int >::sptr":
    r"""divide_ii_make(size_t vlen=1) -> divide_ii_sptr"""
    return _blocks_swig7.divide_ii_make(vlen)

class divide_ii_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::divide< std::int32_t > > class."""

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

    def __init__(self, *args):
        r"""
        __init__(divide_ii_sptr self) -> divide_ii_sptr
        __init__(divide_ii_sptr self, divide_ii p) -> divide_ii_sptr
        """
        _blocks_swig7.divide_ii_sptr_swiginit(self, _blocks_swig7.new_divide_ii_sptr(*args))

    def __deref__(self) -> "gr::blocks::divide< std::int32_t > *":
        r"""__deref__(divide_ii_sptr self) -> divide_ii"""
        return _blocks_swig7.divide_ii_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig7.delete_divide_ii_sptr

    def make(self, vlen: "size_t"=1) -> "gr::blocks::divide< int >::sptr":
        r"""make(divide_ii_sptr self, size_t vlen=1) -> divide_ii_sptr"""
        return _blocks_swig7.divide_ii_sptr_make(self, vlen)

    def history(self) -> "unsigned int":
        r"""history(divide_ii_sptr self) -> unsigned int"""
        return _blocks_swig7.divide_ii_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(divide_ii_sptr self, int which, int delay)
        declare_sample_delay(divide_ii_sptr self, unsigned int delay)
        """
        return _blocks_swig7.divide_ii_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(divide_ii_sptr self, int which) -> unsigned int"""
        return _blocks_swig7.divide_ii_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(divide_ii_sptr self, int multiple)"""
        return _blocks_swig7.divide_ii_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(divide_ii_sptr self) -> int"""
        return _blocks_swig7.divide_ii_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(divide_ii_sptr self) -> double"""
        return _blocks_swig7.divide_ii_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(divide_ii_sptr self) -> uint64_t"""
        return _blocks_swig7.divide_ii_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(divide_ii_sptr self) -> uint64_t"""
        return _blocks_swig7.divide_ii_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(divide_ii_sptr self) -> bool"""
        return _blocks_swig7.divide_ii_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(divide_ii_sptr self) -> bool"""
        return _blocks_swig7.divide_ii_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(divide_ii_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig7.divide_ii_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(divide_ii_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig7.divide_ii_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(divide_ii_sptr self, std::string level)"""
        return _blocks_swig7.divide_ii_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(divide_ii_sptr self) -> std::string"""
        return _blocks_swig7.divide_ii_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(divide_ii_sptr self) -> int"""
        return _blocks_swig7.divide_ii_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(divide_ii_sptr self, int m)"""
        return _blocks_swig7.divide_ii_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(divide_ii_sptr self)"""
        return _blocks_swig7.divide_ii_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(divide_ii_sptr self) -> bool"""
        return _blocks_swig7.divide_ii_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(divide_ii_sptr self, int m)"""
        return _blocks_swig7.divide_ii_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(divide_ii_sptr self) -> int"""
        return _blocks_swig7.divide_ii_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(divide_ii_sptr self, int i) -> long"""
        return _blocks_swig7.divide_ii_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(divide_ii_sptr self, long max_output_buffer)
        set_max_output_buffer(divide_ii_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig7.divide_ii_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(divide_ii_sptr self, int i) -> long"""
        return _blocks_swig7.divide_ii_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(divide_ii_sptr self, long min_output_buffer)
        set_min_output_buffer(divide_ii_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig7.divide_ii_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(divide_ii_sptr self) -> float"""
        return _blocks_swig7.divide_ii_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(divide_ii_sptr self) -> float"""
        return _blocks_swig7.divide_ii_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(divide_ii_sptr self) -> float"""
        return _blocks_swig7.divide_ii_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(divide_ii_sptr self) -> float"""
        return _blocks_swig7.divide_ii_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(divide_ii_sptr self) -> float"""
        return _blocks_swig7.divide_ii_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(divide_ii_sptr self) -> float"""
        return _blocks_swig7.divide_ii_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(divide_ii_sptr self, int which) -> float
        pc_input_buffers_full(divide_ii_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.divide_ii_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(divide_ii_sptr self, int which) -> float
        pc_input_buffers_full_avg(divide_ii_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.divide_ii_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(divide_ii_sptr self, int which) -> float
        pc_input_buffers_full_var(divide_ii_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.divide_ii_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(divide_ii_sptr self, int which) -> float
        pc_output_buffers_full(divide_ii_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.divide_ii_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(divide_ii_sptr self, int which) -> float
        pc_output_buffers_full_avg(divide_ii_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.divide_ii_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(divide_ii_sptr self, int which) -> float
        pc_output_buffers_full_var(divide_ii_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.divide_ii_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(divide_ii_sptr self) -> float"""
        return _blocks_swig7.divide_ii_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(divide_ii_sptr self) -> float"""
        return _blocks_swig7.divide_ii_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(divide_ii_sptr self) -> float"""
        return _blocks_swig7.divide_ii_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(divide_ii_sptr self) -> float"""
        return _blocks_swig7.divide_ii_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(divide_ii_sptr self) -> float"""
        return _blocks_swig7.divide_ii_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(divide_ii_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig7.divide_ii_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(divide_ii_sptr self)"""
        return _blocks_swig7.divide_ii_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(divide_ii_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig7.divide_ii_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(divide_ii_sptr self) -> int"""
        return _blocks_swig7.divide_ii_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(divide_ii_sptr self) -> int"""
        return _blocks_swig7.divide_ii_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(divide_ii_sptr self, int priority) -> int"""
        return _blocks_swig7.divide_ii_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(divide_ii_sptr self) -> std::string"""
        return _blocks_swig7.divide_ii_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(divide_ii_sptr self) -> std::string"""
        return _blocks_swig7.divide_ii_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(divide_ii_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.divide_ii_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(divide_ii_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.divide_ii_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(divide_ii_sptr self) -> long"""
        return _blocks_swig7.divide_ii_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(divide_ii_sptr self) -> basic_block_sptr"""
        return _blocks_swig7.divide_ii_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(divide_ii_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig7.divide_ii_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(divide_ii_sptr self) -> std::string"""
        return _blocks_swig7.divide_ii_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(divide_ii_sptr self, std::string name)"""
        return _blocks_swig7.divide_ii_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(divide_ii_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig7.divide_ii_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(divide_ii_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig7.divide_ii_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(divide_ii_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig7.divide_ii_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(divide_ii_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig7.divide_ii_sptr_message_subscribers(self, which_port)

# Register divide_ii_sptr in _blocks_swig7:
_blocks_swig7.divide_ii_sptr_swigregister(divide_ii_sptr)


divide_ii_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
divide_ii = divide_ii.make

class divide_cc(object):
    r"""Proxy of C++ gr::blocks::divide< gr_complex > 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(vlen: "size_t"=1) -> "gr::blocks::divide< std::complex< float > >::sptr":
        r"""make(size_t vlen=1) -> divide_cc_sptr"""
        return _blocks_swig7.divide_cc_make(vlen)
    __swig_destroy__ = _blocks_swig7.delete_divide_cc

# Register divide_cc in _blocks_swig7:
_blocks_swig7.divide_cc_swigregister(divide_cc)

def divide_cc_make(vlen: "size_t"=1) -> "gr::blocks::divide< std::complex< float > >::sptr":
    r"""divide_cc_make(size_t vlen=1) -> divide_cc_sptr"""
    return _blocks_swig7.divide_cc_make(vlen)

class divide_cc_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::divide< gr_complex > > 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__(divide_cc_sptr self) -> divide_cc_sptr
        __init__(divide_cc_sptr self, divide_cc p) -> divide_cc_sptr
        """
        _blocks_swig7.divide_cc_sptr_swiginit(self, _blocks_swig7.new_divide_cc_sptr(*args))

    def __deref__(self) -> "gr::blocks::divide< gr_complex > *":
        r"""__deref__(divide_cc_sptr self) -> divide_cc"""
        return _blocks_swig7.divide_cc_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig7.delete_divide_cc_sptr

    def make(self, vlen: "size_t"=1) -> "gr::blocks::divide< std::complex< float > >::sptr":
        r"""make(divide_cc_sptr self, size_t vlen=1) -> divide_cc_sptr"""
        return _blocks_swig7.divide_cc_sptr_make(self, vlen)

    def history(self) -> "unsigned int":
        r"""history(divide_cc_sptr self) -> unsigned int"""
        return _blocks_swig7.divide_cc_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(divide_cc_sptr self, int which, int delay)
        declare_sample_delay(divide_cc_sptr self, unsigned int delay)
        """
        return _blocks_swig7.divide_cc_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(divide_cc_sptr self, int which) -> unsigned int"""
        return _blocks_swig7.divide_cc_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(divide_cc_sptr self, int multiple)"""
        return _blocks_swig7.divide_cc_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(divide_cc_sptr self) -> int"""
        return _blocks_swig7.divide_cc_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(divide_cc_sptr self) -> double"""
        return _blocks_swig7.divide_cc_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(divide_cc_sptr self) -> uint64_t"""
        return _blocks_swig7.divide_cc_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(divide_cc_sptr self) -> uint64_t"""
        return _blocks_swig7.divide_cc_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(divide_cc_sptr self) -> bool"""
        return _blocks_swig7.divide_cc_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(divide_cc_sptr self) -> bool"""
        return _blocks_swig7.divide_cc_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(divide_cc_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig7.divide_cc_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(divide_cc_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig7.divide_cc_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(divide_cc_sptr self, std::string level)"""
        return _blocks_swig7.divide_cc_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(divide_cc_sptr self) -> std::string"""
        return _blocks_swig7.divide_cc_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(divide_cc_sptr self) -> int"""
        return _blocks_swig7.divide_cc_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(divide_cc_sptr self, int m)"""
        return _blocks_swig7.divide_cc_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(divide_cc_sptr self)"""
        return _blocks_swig7.divide_cc_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(divide_cc_sptr self) -> bool"""
        return _blocks_swig7.divide_cc_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(divide_cc_sptr self, int m)"""
        return _blocks_swig7.divide_cc_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(divide_cc_sptr self) -> int"""
        return _blocks_swig7.divide_cc_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(divide_cc_sptr self, int i) -> long"""
        return _blocks_swig7.divide_cc_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(divide_cc_sptr self, long max_output_buffer)
        set_max_output_buffer(divide_cc_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig7.divide_cc_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(divide_cc_sptr self, int i) -> long"""
        return _blocks_swig7.divide_cc_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(divide_cc_sptr self, long min_output_buffer)
        set_min_output_buffer(divide_cc_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig7.divide_cc_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(divide_cc_sptr self) -> float"""
        return _blocks_swig7.divide_cc_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(divide_cc_sptr self) -> float"""
        return _blocks_swig7.divide_cc_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(divide_cc_sptr self) -> float"""
        return _blocks_swig7.divide_cc_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(divide_cc_sptr self) -> float"""
        return _blocks_swig7.divide_cc_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(divide_cc_sptr self) -> float"""
        return _blocks_swig7.divide_cc_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(divide_cc_sptr self) -> float"""
        return _blocks_swig7.divide_cc_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(divide_cc_sptr self, int which) -> float
        pc_input_buffers_full(divide_cc_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.divide_cc_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(divide_cc_sptr self, int which) -> float
        pc_input_buffers_full_avg(divide_cc_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.divide_cc_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(divide_cc_sptr self, int which) -> float
        pc_input_buffers_full_var(divide_cc_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.divide_cc_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(divide_cc_sptr self, int which) -> float
        pc_output_buffers_full(divide_cc_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.divide_cc_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(divide_cc_sptr self, int which) -> float
        pc_output_buffers_full_avg(divide_cc_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.divide_cc_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(divide_cc_sptr self, int which) -> float
        pc_output_buffers_full_var(divide_cc_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.divide_cc_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(divide_cc_sptr self) -> float"""
        return _blocks_swig7.divide_cc_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(divide_cc_sptr self) -> float"""
        return _blocks_swig7.divide_cc_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(divide_cc_sptr self) -> float"""
        return _blocks_swig7.divide_cc_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(divide_cc_sptr self) -> float"""
        return _blocks_swig7.divide_cc_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(divide_cc_sptr self) -> float"""
        return _blocks_swig7.divide_cc_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(divide_cc_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig7.divide_cc_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(divide_cc_sptr self)"""
        return _blocks_swig7.divide_cc_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(divide_cc_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig7.divide_cc_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(divide_cc_sptr self) -> int"""
        return _blocks_swig7.divide_cc_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(divide_cc_sptr self) -> int"""
        return _blocks_swig7.divide_cc_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(divide_cc_sptr self, int priority) -> int"""
        return _blocks_swig7.divide_cc_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(divide_cc_sptr self) -> std::string"""
        return _blocks_swig7.divide_cc_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(divide_cc_sptr self) -> std::string"""
        return _blocks_swig7.divide_cc_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(divide_cc_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.divide_cc_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(divide_cc_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.divide_cc_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(divide_cc_sptr self) -> long"""
        return _blocks_swig7.divide_cc_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(divide_cc_sptr self) -> basic_block_sptr"""
        return _blocks_swig7.divide_cc_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(divide_cc_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig7.divide_cc_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(divide_cc_sptr self) -> std::string"""
        return _blocks_swig7.divide_cc_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(divide_cc_sptr self, std::string name)"""
        return _blocks_swig7.divide_cc_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(divide_cc_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig7.divide_cc_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(divide_cc_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig7.divide_cc_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(divide_cc_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig7.divide_cc_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(divide_cc_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig7.divide_cc_sptr_message_subscribers(self, which_port)

# Register divide_cc_sptr in _blocks_swig7:
_blocks_swig7.divide_cc_sptr_swigregister(divide_cc_sptr)


divide_cc_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
divide_cc = divide_cc.make

class exponentiate_const_cci_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::exponentiate_const_cci > 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__(exponentiate_const_cci_sptr self) -> exponentiate_const_cci_sptr
        __init__(exponentiate_const_cci_sptr self, exponentiate_const_cci p) -> exponentiate_const_cci_sptr
        """
        _blocks_swig7.exponentiate_const_cci_sptr_swiginit(self, _blocks_swig7.new_exponentiate_const_cci_sptr(*args))

    def __deref__(self) -> "gr::blocks::exponentiate_const_cci *":
        r"""__deref__(exponentiate_const_cci_sptr self) -> exponentiate_const_cci"""
        return _blocks_swig7.exponentiate_const_cci_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig7.delete_exponentiate_const_cci_sptr

    def make(self, exponent: "int", vlen: "size_t"=1) -> "gr::blocks::exponentiate_const_cci::sptr":
        r"""make(exponentiate_const_cci_sptr self, int exponent, size_t vlen=1) -> exponentiate_const_cci_sptr"""
        return _blocks_swig7.exponentiate_const_cci_sptr_make(self, exponent, vlen)

    def set_exponent(self, exponent: "int") -> "void":
        r"""set_exponent(exponentiate_const_cci_sptr self, int exponent)"""
        return _blocks_swig7.exponentiate_const_cci_sptr_set_exponent(self, exponent)

    def history(self) -> "unsigned int":
        r"""history(exponentiate_const_cci_sptr self) -> unsigned int"""
        return _blocks_swig7.exponentiate_const_cci_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(exponentiate_const_cci_sptr self, int which, int delay)
        declare_sample_delay(exponentiate_const_cci_sptr self, unsigned int delay)
        """
        return _blocks_swig7.exponentiate_const_cci_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(exponentiate_const_cci_sptr self, int which) -> unsigned int"""
        return _blocks_swig7.exponentiate_const_cci_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(exponentiate_const_cci_sptr self, int multiple)"""
        return _blocks_swig7.exponentiate_const_cci_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(exponentiate_const_cci_sptr self) -> int"""
        return _blocks_swig7.exponentiate_const_cci_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(exponentiate_const_cci_sptr self) -> double"""
        return _blocks_swig7.exponentiate_const_cci_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(exponentiate_const_cci_sptr self) -> uint64_t"""
        return _blocks_swig7.exponentiate_const_cci_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(exponentiate_const_cci_sptr self) -> uint64_t"""
        return _blocks_swig7.exponentiate_const_cci_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(exponentiate_const_cci_sptr self) -> bool"""
        return _blocks_swig7.exponentiate_const_cci_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(exponentiate_const_cci_sptr self) -> bool"""
        return _blocks_swig7.exponentiate_const_cci_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(exponentiate_const_cci_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig7.exponentiate_const_cci_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(exponentiate_const_cci_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig7.exponentiate_const_cci_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(exponentiate_const_cci_sptr self, std::string level)"""
        return _blocks_swig7.exponentiate_const_cci_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(exponentiate_const_cci_sptr self) -> std::string"""
        return _blocks_swig7.exponentiate_const_cci_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(exponentiate_const_cci_sptr self) -> int"""
        return _blocks_swig7.exponentiate_const_cci_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(exponentiate_const_cci_sptr self, int m)"""
        return _blocks_swig7.exponentiate_const_cci_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(exponentiate_const_cci_sptr self)"""
        return _blocks_swig7.exponentiate_const_cci_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(exponentiate_const_cci_sptr self) -> bool"""
        return _blocks_swig7.exponentiate_const_cci_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(exponentiate_const_cci_sptr self, int m)"""
        return _blocks_swig7.exponentiate_const_cci_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(exponentiate_const_cci_sptr self) -> int"""
        return _blocks_swig7.exponentiate_const_cci_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(exponentiate_const_cci_sptr self, int i) -> long"""
        return _blocks_swig7.exponentiate_const_cci_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(exponentiate_const_cci_sptr self, long max_output_buffer)
        set_max_output_buffer(exponentiate_const_cci_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig7.exponentiate_const_cci_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(exponentiate_const_cci_sptr self, int i) -> long"""
        return _blocks_swig7.exponentiate_const_cci_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(exponentiate_const_cci_sptr self, long min_output_buffer)
        set_min_output_buffer(exponentiate_const_cci_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig7.exponentiate_const_cci_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(exponentiate_const_cci_sptr self) -> float"""
        return _blocks_swig7.exponentiate_const_cci_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(exponentiate_const_cci_sptr self) -> float"""
        return _blocks_swig7.exponentiate_const_cci_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(exponentiate_const_cci_sptr self) -> float"""
        return _blocks_swig7.exponentiate_const_cci_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(exponentiate_const_cci_sptr self) -> float"""
        return _blocks_swig7.exponentiate_const_cci_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(exponentiate_const_cci_sptr self) -> float"""
        return _blocks_swig7.exponentiate_const_cci_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(exponentiate_const_cci_sptr self) -> float"""
        return _blocks_swig7.exponentiate_const_cci_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(exponentiate_const_cci_sptr self, int which) -> float
        pc_input_buffers_full(exponentiate_const_cci_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.exponentiate_const_cci_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(exponentiate_const_cci_sptr self, int which) -> float
        pc_input_buffers_full_avg(exponentiate_const_cci_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.exponentiate_const_cci_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(exponentiate_const_cci_sptr self, int which) -> float
        pc_input_buffers_full_var(exponentiate_const_cci_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.exponentiate_const_cci_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(exponentiate_const_cci_sptr self, int which) -> float
        pc_output_buffers_full(exponentiate_const_cci_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.exponentiate_const_cci_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(exponentiate_const_cci_sptr self, int which) -> float
        pc_output_buffers_full_avg(exponentiate_const_cci_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.exponentiate_const_cci_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(exponentiate_const_cci_sptr self, int which) -> float
        pc_output_buffers_full_var(exponentiate_const_cci_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.exponentiate_const_cci_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(exponentiate_const_cci_sptr self) -> float"""
        return _blocks_swig7.exponentiate_const_cci_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(exponentiate_const_cci_sptr self) -> float"""
        return _blocks_swig7.exponentiate_const_cci_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(exponentiate_const_cci_sptr self) -> float"""
        return _blocks_swig7.exponentiate_const_cci_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(exponentiate_const_cci_sptr self) -> float"""
        return _blocks_swig7.exponentiate_const_cci_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(exponentiate_const_cci_sptr self) -> float"""
        return _blocks_swig7.exponentiate_const_cci_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(exponentiate_const_cci_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig7.exponentiate_const_cci_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(exponentiate_const_cci_sptr self)"""
        return _blocks_swig7.exponentiate_const_cci_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(exponentiate_const_cci_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig7.exponentiate_const_cci_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(exponentiate_const_cci_sptr self) -> int"""
        return _blocks_swig7.exponentiate_const_cci_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(exponentiate_const_cci_sptr self) -> int"""
        return _blocks_swig7.exponentiate_const_cci_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(exponentiate_const_cci_sptr self, int priority) -> int"""
        return _blocks_swig7.exponentiate_const_cci_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(exponentiate_const_cci_sptr self) -> std::string"""
        return _blocks_swig7.exponentiate_const_cci_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(exponentiate_const_cci_sptr self) -> std::string"""
        return _blocks_swig7.exponentiate_const_cci_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(exponentiate_const_cci_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.exponentiate_const_cci_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(exponentiate_const_cci_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.exponentiate_const_cci_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(exponentiate_const_cci_sptr self) -> long"""
        return _blocks_swig7.exponentiate_const_cci_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(exponentiate_const_cci_sptr self) -> basic_block_sptr"""
        return _blocks_swig7.exponentiate_const_cci_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(exponentiate_const_cci_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig7.exponentiate_const_cci_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(exponentiate_const_cci_sptr self) -> std::string"""
        return _blocks_swig7.exponentiate_const_cci_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(exponentiate_const_cci_sptr self, std::string name)"""
        return _blocks_swig7.exponentiate_const_cci_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(exponentiate_const_cci_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig7.exponentiate_const_cci_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(exponentiate_const_cci_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig7.exponentiate_const_cci_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(exponentiate_const_cci_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig7.exponentiate_const_cci_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(exponentiate_const_cci_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig7.exponentiate_const_cci_sptr_message_subscribers(self, which_port)

# Register exponentiate_const_cci_sptr in _blocks_swig7:
_blocks_swig7.exponentiate_const_cci_sptr_swigregister(exponentiate_const_cci_sptr)


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

class selector_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::selector > 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__(selector_sptr self) -> selector_sptr
        __init__(selector_sptr self, selector p) -> selector_sptr
        """
        _blocks_swig7.selector_sptr_swiginit(self, _blocks_swig7.new_selector_sptr(*args))

    def __deref__(self) -> "gr::blocks::selector *":
        r"""__deref__(selector_sptr self) -> selector"""
        return _blocks_swig7.selector_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig7.delete_selector_sptr

    def make(self, itemsize: "size_t", input_index: "unsigned int", output_index: "unsigned int") -> "gr::blocks::selector::sptr":
        r"""make(selector_sptr self, size_t itemsize, unsigned int input_index, unsigned int output_index) -> selector_sptr"""
        return _blocks_swig7.selector_sptr_make(self, itemsize, input_index, output_index)

    def set_enabled(self, enable: "bool") -> "void":
        r"""set_enabled(selector_sptr self, bool enable)"""
        return _blocks_swig7.selector_sptr_set_enabled(self, enable)

    def enabled(self) -> "bool":
        r"""enabled(selector_sptr self) -> bool"""
        return _blocks_swig7.selector_sptr_enabled(self)

    def set_input_index(self, input_index: "unsigned int") -> "void":
        r"""set_input_index(selector_sptr self, unsigned int input_index)"""
        return _blocks_swig7.selector_sptr_set_input_index(self, input_index)

    def input_index(self) -> "int":
        r"""input_index(selector_sptr self) -> int"""
        return _blocks_swig7.selector_sptr_input_index(self)

    def set_output_index(self, output_index: "unsigned int") -> "void":
        r"""set_output_index(selector_sptr self, unsigned int output_index)"""
        return _blocks_swig7.selector_sptr_set_output_index(self, output_index)

    def output_index(self) -> "int":
        r"""output_index(selector_sptr self) -> int"""
        return _blocks_swig7.selector_sptr_output_index(self)

    def history(self) -> "unsigned int":
        r"""history(selector_sptr self) -> unsigned int"""
        return _blocks_swig7.selector_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(selector_sptr self, int which, int delay)
        declare_sample_delay(selector_sptr self, unsigned int delay)
        """
        return _blocks_swig7.selector_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(selector_sptr self, int which) -> unsigned int"""
        return _blocks_swig7.selector_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(selector_sptr self, int multiple)"""
        return _blocks_swig7.selector_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(selector_sptr self) -> int"""
        return _blocks_swig7.selector_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(selector_sptr self) -> double"""
        return _blocks_swig7.selector_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(selector_sptr self) -> uint64_t"""
        return _blocks_swig7.selector_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(selector_sptr self) -> uint64_t"""
        return _blocks_swig7.selector_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(selector_sptr self) -> bool"""
        return _blocks_swig7.selector_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(selector_sptr self) -> bool"""
        return _blocks_swig7.selector_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(selector_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig7.selector_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(selector_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig7.selector_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(selector_sptr self, std::string level)"""
        return _blocks_swig7.selector_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(selector_sptr self) -> std::string"""
        return _blocks_swig7.selector_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(selector_sptr self) -> int"""
        return _blocks_swig7.selector_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(selector_sptr self, int m)"""
        return _blocks_swig7.selector_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(selector_sptr self)"""
        return _blocks_swig7.selector_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(selector_sptr self) -> bool"""
        return _blocks_swig7.selector_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(selector_sptr self, int m)"""
        return _blocks_swig7.selector_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(selector_sptr self) -> int"""
        return _blocks_swig7.selector_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(selector_sptr self, int i) -> long"""
        return _blocks_swig7.selector_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(selector_sptr self, long max_output_buffer)
        set_max_output_buffer(selector_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig7.selector_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(selector_sptr self, int i) -> long"""
        return _blocks_swig7.selector_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(selector_sptr self, long min_output_buffer)
        set_min_output_buffer(selector_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig7.selector_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(selector_sptr self) -> float"""
        return _blocks_swig7.selector_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(selector_sptr self) -> float"""
        return _blocks_swig7.selector_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(selector_sptr self) -> float"""
        return _blocks_swig7.selector_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(selector_sptr self) -> float"""
        return _blocks_swig7.selector_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(selector_sptr self) -> float"""
        return _blocks_swig7.selector_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(selector_sptr self) -> float"""
        return _blocks_swig7.selector_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(selector_sptr self, int which) -> float
        pc_input_buffers_full(selector_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.selector_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(selector_sptr self, int which) -> float
        pc_input_buffers_full_avg(selector_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.selector_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(selector_sptr self, int which) -> float
        pc_input_buffers_full_var(selector_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.selector_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(selector_sptr self, int which) -> float
        pc_output_buffers_full(selector_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.selector_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(selector_sptr self, int which) -> float
        pc_output_buffers_full_avg(selector_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.selector_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(selector_sptr self, int which) -> float
        pc_output_buffers_full_var(selector_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.selector_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(selector_sptr self) -> float"""
        return _blocks_swig7.selector_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(selector_sptr self) -> float"""
        return _blocks_swig7.selector_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(selector_sptr self) -> float"""
        return _blocks_swig7.selector_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(selector_sptr self) -> float"""
        return _blocks_swig7.selector_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(selector_sptr self) -> float"""
        return _blocks_swig7.selector_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(selector_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig7.selector_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(selector_sptr self)"""
        return _blocks_swig7.selector_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(selector_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig7.selector_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(selector_sptr self) -> int"""
        return _blocks_swig7.selector_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(selector_sptr self) -> int"""
        return _blocks_swig7.selector_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(selector_sptr self, int priority) -> int"""
        return _blocks_swig7.selector_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(selector_sptr self) -> std::string"""
        return _blocks_swig7.selector_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(selector_sptr self) -> std::string"""
        return _blocks_swig7.selector_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(selector_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.selector_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(selector_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.selector_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(selector_sptr self) -> long"""
        return _blocks_swig7.selector_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(selector_sptr self) -> basic_block_sptr"""
        return _blocks_swig7.selector_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(selector_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig7.selector_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(selector_sptr self) -> std::string"""
        return _blocks_swig7.selector_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(selector_sptr self, std::string name)"""
        return _blocks_swig7.selector_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(selector_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig7.selector_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(selector_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig7.selector_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(selector_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig7.selector_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(selector_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig7.selector_sptr_message_subscribers(self, which_port)

# Register selector_sptr in _blocks_swig7:
_blocks_swig7.selector_sptr_swigregister(selector_sptr)


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

class skiphead_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::skiphead > 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__(skiphead_sptr self) -> skiphead_sptr
        __init__(skiphead_sptr self, skiphead p) -> skiphead_sptr
        """
        _blocks_swig7.skiphead_sptr_swiginit(self, _blocks_swig7.new_skiphead_sptr(*args))

    def __deref__(self) -> "gr::blocks::skiphead *":
        r"""__deref__(skiphead_sptr self) -> skiphead"""
        return _blocks_swig7.skiphead_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig7.delete_skiphead_sptr

    def make(self, itemsize: "size_t", nitems_to_skip: "uint64_t") -> "gr::blocks::skiphead::sptr":
        r"""make(skiphead_sptr self, size_t itemsize, uint64_t nitems_to_skip) -> skiphead_sptr"""
        return _blocks_swig7.skiphead_sptr_make(self, itemsize, nitems_to_skip)

    def history(self) -> "unsigned int":
        r"""history(skiphead_sptr self) -> unsigned int"""
        return _blocks_swig7.skiphead_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(skiphead_sptr self, int which, int delay)
        declare_sample_delay(skiphead_sptr self, unsigned int delay)
        """
        return _blocks_swig7.skiphead_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(skiphead_sptr self, int which) -> unsigned int"""
        return _blocks_swig7.skiphead_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(skiphead_sptr self, int multiple)"""
        return _blocks_swig7.skiphead_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(skiphead_sptr self) -> int"""
        return _blocks_swig7.skiphead_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(skiphead_sptr self) -> double"""
        return _blocks_swig7.skiphead_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(skiphead_sptr self) -> uint64_t"""
        return _blocks_swig7.skiphead_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(skiphead_sptr self) -> uint64_t"""
        return _blocks_swig7.skiphead_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(skiphead_sptr self) -> bool"""
        return _blocks_swig7.skiphead_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(skiphead_sptr self) -> bool"""
        return _blocks_swig7.skiphead_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(skiphead_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig7.skiphead_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(skiphead_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig7.skiphead_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(skiphead_sptr self, std::string level)"""
        return _blocks_swig7.skiphead_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(skiphead_sptr self) -> std::string"""
        return _blocks_swig7.skiphead_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(skiphead_sptr self) -> int"""
        return _blocks_swig7.skiphead_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(skiphead_sptr self, int m)"""
        return _blocks_swig7.skiphead_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(skiphead_sptr self)"""
        return _blocks_swig7.skiphead_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(skiphead_sptr self) -> bool"""
        return _blocks_swig7.skiphead_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(skiphead_sptr self, int m)"""
        return _blocks_swig7.skiphead_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(skiphead_sptr self) -> int"""
        return _blocks_swig7.skiphead_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(skiphead_sptr self, int i) -> long"""
        return _blocks_swig7.skiphead_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(skiphead_sptr self, long max_output_buffer)
        set_max_output_buffer(skiphead_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig7.skiphead_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(skiphead_sptr self, int i) -> long"""
        return _blocks_swig7.skiphead_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(skiphead_sptr self, long min_output_buffer)
        set_min_output_buffer(skiphead_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig7.skiphead_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(skiphead_sptr self) -> float"""
        return _blocks_swig7.skiphead_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(skiphead_sptr self) -> float"""
        return _blocks_swig7.skiphead_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(skiphead_sptr self) -> float"""
        return _blocks_swig7.skiphead_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(skiphead_sptr self) -> float"""
        return _blocks_swig7.skiphead_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(skiphead_sptr self) -> float"""
        return _blocks_swig7.skiphead_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(skiphead_sptr self) -> float"""
        return _blocks_swig7.skiphead_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(skiphead_sptr self, int which) -> float
        pc_input_buffers_full(skiphead_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.skiphead_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(skiphead_sptr self, int which) -> float
        pc_input_buffers_full_avg(skiphead_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.skiphead_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(skiphead_sptr self, int which) -> float
        pc_input_buffers_full_var(skiphead_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.skiphead_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(skiphead_sptr self, int which) -> float
        pc_output_buffers_full(skiphead_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.skiphead_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(skiphead_sptr self, int which) -> float
        pc_output_buffers_full_avg(skiphead_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.skiphead_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(skiphead_sptr self, int which) -> float
        pc_output_buffers_full_var(skiphead_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.skiphead_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(skiphead_sptr self) -> float"""
        return _blocks_swig7.skiphead_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(skiphead_sptr self) -> float"""
        return _blocks_swig7.skiphead_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(skiphead_sptr self) -> float"""
        return _blocks_swig7.skiphead_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(skiphead_sptr self) -> float"""
        return _blocks_swig7.skiphead_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(skiphead_sptr self) -> float"""
        return _blocks_swig7.skiphead_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(skiphead_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig7.skiphead_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(skiphead_sptr self)"""
        return _blocks_swig7.skiphead_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(skiphead_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig7.skiphead_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(skiphead_sptr self) -> int"""
        return _blocks_swig7.skiphead_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(skiphead_sptr self) -> int"""
        return _blocks_swig7.skiphead_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(skiphead_sptr self, int priority) -> int"""
        return _blocks_swig7.skiphead_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(skiphead_sptr self) -> std::string"""
        return _blocks_swig7.skiphead_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(skiphead_sptr self) -> std::string"""
        return _blocks_swig7.skiphead_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(skiphead_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.skiphead_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(skiphead_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.skiphead_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(skiphead_sptr self) -> long"""
        return _blocks_swig7.skiphead_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(skiphead_sptr self) -> basic_block_sptr"""
        return _blocks_swig7.skiphead_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(skiphead_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig7.skiphead_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(skiphead_sptr self) -> std::string"""
        return _blocks_swig7.skiphead_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(skiphead_sptr self, std::string name)"""
        return _blocks_swig7.skiphead_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(skiphead_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig7.skiphead_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(skiphead_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig7.skiphead_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(skiphead_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig7.skiphead_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(skiphead_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig7.skiphead_sptr_message_subscribers(self, which_port)

# Register skiphead_sptr in _blocks_swig7:
_blocks_swig7.skiphead_sptr_swigregister(skiphead_sptr)


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

class stream_mux_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::stream_mux > 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__(stream_mux_sptr self) -> stream_mux_sptr
        __init__(stream_mux_sptr self, stream_mux p) -> stream_mux_sptr
        """
        _blocks_swig7.stream_mux_sptr_swiginit(self, _blocks_swig7.new_stream_mux_sptr(*args))

    def __deref__(self) -> "gr::blocks::stream_mux *":
        r"""__deref__(stream_mux_sptr self) -> stream_mux"""
        return _blocks_swig7.stream_mux_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig7.delete_stream_mux_sptr

    def make(self, itemsize: "size_t", lengths: "std::vector< int,std::allocator< int > > const &") -> "gr::blocks::stream_mux::sptr":
        r"""make(stream_mux_sptr self, size_t itemsize, std::vector< int,std::allocator< int > > const & lengths) -> stream_mux_sptr"""
        return _blocks_swig7.stream_mux_sptr_make(self, itemsize, lengths)

    def history(self) -> "unsigned int":
        r"""history(stream_mux_sptr self) -> unsigned int"""
        return _blocks_swig7.stream_mux_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(stream_mux_sptr self, int which, int delay)
        declare_sample_delay(stream_mux_sptr self, unsigned int delay)
        """
        return _blocks_swig7.stream_mux_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(stream_mux_sptr self, int which) -> unsigned int"""
        return _blocks_swig7.stream_mux_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(stream_mux_sptr self, int multiple)"""
        return _blocks_swig7.stream_mux_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(stream_mux_sptr self) -> int"""
        return _blocks_swig7.stream_mux_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(stream_mux_sptr self) -> double"""
        return _blocks_swig7.stream_mux_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(stream_mux_sptr self) -> uint64_t"""
        return _blocks_swig7.stream_mux_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(stream_mux_sptr self) -> uint64_t"""
        return _blocks_swig7.stream_mux_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(stream_mux_sptr self) -> bool"""
        return _blocks_swig7.stream_mux_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(stream_mux_sptr self) -> bool"""
        return _blocks_swig7.stream_mux_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(stream_mux_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig7.stream_mux_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(stream_mux_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig7.stream_mux_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(stream_mux_sptr self, std::string level)"""
        return _blocks_swig7.stream_mux_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(stream_mux_sptr self) -> std::string"""
        return _blocks_swig7.stream_mux_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(stream_mux_sptr self) -> int"""
        return _blocks_swig7.stream_mux_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(stream_mux_sptr self, int m)"""
        return _blocks_swig7.stream_mux_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(stream_mux_sptr self)"""
        return _blocks_swig7.stream_mux_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(stream_mux_sptr self) -> bool"""
        return _blocks_swig7.stream_mux_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(stream_mux_sptr self, int m)"""
        return _blocks_swig7.stream_mux_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(stream_mux_sptr self) -> int"""
        return _blocks_swig7.stream_mux_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(stream_mux_sptr self, int i) -> long"""
        return _blocks_swig7.stream_mux_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(stream_mux_sptr self, long max_output_buffer)
        set_max_output_buffer(stream_mux_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig7.stream_mux_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(stream_mux_sptr self, int i) -> long"""
        return _blocks_swig7.stream_mux_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(stream_mux_sptr self, long min_output_buffer)
        set_min_output_buffer(stream_mux_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig7.stream_mux_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(stream_mux_sptr self) -> float"""
        return _blocks_swig7.stream_mux_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(stream_mux_sptr self) -> float"""
        return _blocks_swig7.stream_mux_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(stream_mux_sptr self) -> float"""
        return _blocks_swig7.stream_mux_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(stream_mux_sptr self) -> float"""
        return _blocks_swig7.stream_mux_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(stream_mux_sptr self) -> float"""
        return _blocks_swig7.stream_mux_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(stream_mux_sptr self) -> float"""
        return _blocks_swig7.stream_mux_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(stream_mux_sptr self, int which) -> float
        pc_input_buffers_full(stream_mux_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.stream_mux_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(stream_mux_sptr self, int which) -> float
        pc_input_buffers_full_avg(stream_mux_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.stream_mux_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(stream_mux_sptr self, int which) -> float
        pc_input_buffers_full_var(stream_mux_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.stream_mux_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(stream_mux_sptr self, int which) -> float
        pc_output_buffers_full(stream_mux_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.stream_mux_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(stream_mux_sptr self, int which) -> float
        pc_output_buffers_full_avg(stream_mux_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.stream_mux_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(stream_mux_sptr self, int which) -> float
        pc_output_buffers_full_var(stream_mux_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.stream_mux_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(stream_mux_sptr self) -> float"""
        return _blocks_swig7.stream_mux_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(stream_mux_sptr self) -> float"""
        return _blocks_swig7.stream_mux_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(stream_mux_sptr self) -> float"""
        return _blocks_swig7.stream_mux_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(stream_mux_sptr self) -> float"""
        return _blocks_swig7.stream_mux_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(stream_mux_sptr self) -> float"""
        return _blocks_swig7.stream_mux_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(stream_mux_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig7.stream_mux_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(stream_mux_sptr self)"""
        return _blocks_swig7.stream_mux_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(stream_mux_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig7.stream_mux_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(stream_mux_sptr self) -> int"""
        return _blocks_swig7.stream_mux_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(stream_mux_sptr self) -> int"""
        return _blocks_swig7.stream_mux_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(stream_mux_sptr self, int priority) -> int"""
        return _blocks_swig7.stream_mux_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(stream_mux_sptr self) -> std::string"""
        return _blocks_swig7.stream_mux_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(stream_mux_sptr self) -> std::string"""
        return _blocks_swig7.stream_mux_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(stream_mux_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.stream_mux_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(stream_mux_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.stream_mux_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(stream_mux_sptr self) -> long"""
        return _blocks_swig7.stream_mux_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(stream_mux_sptr self) -> basic_block_sptr"""
        return _blocks_swig7.stream_mux_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(stream_mux_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig7.stream_mux_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(stream_mux_sptr self) -> std::string"""
        return _blocks_swig7.stream_mux_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(stream_mux_sptr self, std::string name)"""
        return _blocks_swig7.stream_mux_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(stream_mux_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig7.stream_mux_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(stream_mux_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig7.stream_mux_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(stream_mux_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig7.stream_mux_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(stream_mux_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig7.stream_mux_sptr_message_subscribers(self, which_port)

# Register stream_mux_sptr in _blocks_swig7:
_blocks_swig7.stream_mux_sptr_swigregister(stream_mux_sptr)


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

class stream_to_streams_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::stream_to_streams > 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__(stream_to_streams_sptr self) -> stream_to_streams_sptr
        __init__(stream_to_streams_sptr self, stream_to_streams p) -> stream_to_streams_sptr
        """
        _blocks_swig7.stream_to_streams_sptr_swiginit(self, _blocks_swig7.new_stream_to_streams_sptr(*args))

    def __deref__(self) -> "gr::blocks::stream_to_streams *":
        r"""__deref__(stream_to_streams_sptr self) -> stream_to_streams"""
        return _blocks_swig7.stream_to_streams_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig7.delete_stream_to_streams_sptr

    def make(self, itemsize: "size_t", nstreams: "size_t") -> "gr::blocks::stream_to_streams::sptr":
        r"""make(stream_to_streams_sptr self, size_t itemsize, size_t nstreams) -> stream_to_streams_sptr"""
        return _blocks_swig7.stream_to_streams_sptr_make(self, itemsize, nstreams)

    def history(self) -> "unsigned int":
        r"""history(stream_to_streams_sptr self) -> unsigned int"""
        return _blocks_swig7.stream_to_streams_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(stream_to_streams_sptr self, int which, int delay)
        declare_sample_delay(stream_to_streams_sptr self, unsigned int delay)
        """
        return _blocks_swig7.stream_to_streams_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(stream_to_streams_sptr self, int which) -> unsigned int"""
        return _blocks_swig7.stream_to_streams_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(stream_to_streams_sptr self, int multiple)"""
        return _blocks_swig7.stream_to_streams_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(stream_to_streams_sptr self) -> int"""
        return _blocks_swig7.stream_to_streams_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(stream_to_streams_sptr self) -> double"""
        return _blocks_swig7.stream_to_streams_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(stream_to_streams_sptr self) -> uint64_t"""
        return _blocks_swig7.stream_to_streams_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(stream_to_streams_sptr self) -> uint64_t"""
        return _blocks_swig7.stream_to_streams_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(stream_to_streams_sptr self) -> bool"""
        return _blocks_swig7.stream_to_streams_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(stream_to_streams_sptr self) -> bool"""
        return _blocks_swig7.stream_to_streams_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(stream_to_streams_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig7.stream_to_streams_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(stream_to_streams_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig7.stream_to_streams_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(stream_to_streams_sptr self, std::string level)"""
        return _blocks_swig7.stream_to_streams_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(stream_to_streams_sptr self) -> std::string"""
        return _blocks_swig7.stream_to_streams_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(stream_to_streams_sptr self) -> int"""
        return _blocks_swig7.stream_to_streams_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(stream_to_streams_sptr self, int m)"""
        return _blocks_swig7.stream_to_streams_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(stream_to_streams_sptr self)"""
        return _blocks_swig7.stream_to_streams_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(stream_to_streams_sptr self) -> bool"""
        return _blocks_swig7.stream_to_streams_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(stream_to_streams_sptr self, int m)"""
        return _blocks_swig7.stream_to_streams_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(stream_to_streams_sptr self) -> int"""
        return _blocks_swig7.stream_to_streams_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(stream_to_streams_sptr self, int i) -> long"""
        return _blocks_swig7.stream_to_streams_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(stream_to_streams_sptr self, long max_output_buffer)
        set_max_output_buffer(stream_to_streams_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig7.stream_to_streams_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(stream_to_streams_sptr self, int i) -> long"""
        return _blocks_swig7.stream_to_streams_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(stream_to_streams_sptr self, long min_output_buffer)
        set_min_output_buffer(stream_to_streams_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig7.stream_to_streams_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(stream_to_streams_sptr self) -> float"""
        return _blocks_swig7.stream_to_streams_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(stream_to_streams_sptr self) -> float"""
        return _blocks_swig7.stream_to_streams_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(stream_to_streams_sptr self) -> float"""
        return _blocks_swig7.stream_to_streams_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(stream_to_streams_sptr self) -> float"""
        return _blocks_swig7.stream_to_streams_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(stream_to_streams_sptr self) -> float"""
        return _blocks_swig7.stream_to_streams_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(stream_to_streams_sptr self) -> float"""
        return _blocks_swig7.stream_to_streams_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(stream_to_streams_sptr self, int which) -> float
        pc_input_buffers_full(stream_to_streams_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.stream_to_streams_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(stream_to_streams_sptr self, int which) -> float
        pc_input_buffers_full_avg(stream_to_streams_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.stream_to_streams_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(stream_to_streams_sptr self, int which) -> float
        pc_input_buffers_full_var(stream_to_streams_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.stream_to_streams_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(stream_to_streams_sptr self, int which) -> float
        pc_output_buffers_full(stream_to_streams_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.stream_to_streams_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(stream_to_streams_sptr self, int which) -> float
        pc_output_buffers_full_avg(stream_to_streams_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.stream_to_streams_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(stream_to_streams_sptr self, int which) -> float
        pc_output_buffers_full_var(stream_to_streams_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.stream_to_streams_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(stream_to_streams_sptr self) -> float"""
        return _blocks_swig7.stream_to_streams_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(stream_to_streams_sptr self) -> float"""
        return _blocks_swig7.stream_to_streams_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(stream_to_streams_sptr self) -> float"""
        return _blocks_swig7.stream_to_streams_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(stream_to_streams_sptr self) -> float"""
        return _blocks_swig7.stream_to_streams_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(stream_to_streams_sptr self) -> float"""
        return _blocks_swig7.stream_to_streams_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(stream_to_streams_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig7.stream_to_streams_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(stream_to_streams_sptr self)"""
        return _blocks_swig7.stream_to_streams_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(stream_to_streams_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig7.stream_to_streams_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(stream_to_streams_sptr self) -> int"""
        return _blocks_swig7.stream_to_streams_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(stream_to_streams_sptr self) -> int"""
        return _blocks_swig7.stream_to_streams_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(stream_to_streams_sptr self, int priority) -> int"""
        return _blocks_swig7.stream_to_streams_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(stream_to_streams_sptr self) -> std::string"""
        return _blocks_swig7.stream_to_streams_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(stream_to_streams_sptr self) -> std::string"""
        return _blocks_swig7.stream_to_streams_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(stream_to_streams_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.stream_to_streams_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(stream_to_streams_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.stream_to_streams_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(stream_to_streams_sptr self) -> long"""
        return _blocks_swig7.stream_to_streams_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(stream_to_streams_sptr self) -> basic_block_sptr"""
        return _blocks_swig7.stream_to_streams_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(stream_to_streams_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig7.stream_to_streams_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(stream_to_streams_sptr self) -> std::string"""
        return _blocks_swig7.stream_to_streams_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(stream_to_streams_sptr self, std::string name)"""
        return _blocks_swig7.stream_to_streams_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(stream_to_streams_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig7.stream_to_streams_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(stream_to_streams_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig7.stream_to_streams_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(stream_to_streams_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig7.stream_to_streams_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(stream_to_streams_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig7.stream_to_streams_sptr_message_subscribers(self, which_port)

# Register stream_to_streams_sptr in _blocks_swig7:
_blocks_swig7.stream_to_streams_sptr_swigregister(stream_to_streams_sptr)


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

class stream_to_tagged_stream_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::stream_to_tagged_stream > 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__(stream_to_tagged_stream_sptr self) -> stream_to_tagged_stream_sptr
        __init__(stream_to_tagged_stream_sptr self, stream_to_tagged_stream p) -> stream_to_tagged_stream_sptr
        """
        _blocks_swig7.stream_to_tagged_stream_sptr_swiginit(self, _blocks_swig7.new_stream_to_tagged_stream_sptr(*args))

    def __deref__(self) -> "gr::blocks::stream_to_tagged_stream *":
        r"""__deref__(stream_to_tagged_stream_sptr self) -> stream_to_tagged_stream"""
        return _blocks_swig7.stream_to_tagged_stream_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig7.delete_stream_to_tagged_stream_sptr

    def make(self, itemsize: "size_t", vlen: "unsigned int", packet_len: "unsigned int", len_tag_key: "std::string const &") -> "gr::blocks::stream_to_tagged_stream::sptr":
        r"""make(stream_to_tagged_stream_sptr self, size_t itemsize, unsigned int vlen, unsigned int packet_len, std::string const & len_tag_key) -> stream_to_tagged_stream_sptr"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_make(self, itemsize, vlen, packet_len, len_tag_key)

    def set_packet_len(self, packet_len: "unsigned int") -> "void":
        r"""set_packet_len(stream_to_tagged_stream_sptr self, unsigned int packet_len)"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_set_packet_len(self, packet_len)

    def set_packet_len_pmt(self, packet_len: "unsigned int") -> "void":
        r"""set_packet_len_pmt(stream_to_tagged_stream_sptr self, unsigned int packet_len)"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_set_packet_len_pmt(self, packet_len)

    def history(self) -> "unsigned int":
        r"""history(stream_to_tagged_stream_sptr self) -> unsigned int"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(stream_to_tagged_stream_sptr self, int which, int delay)
        declare_sample_delay(stream_to_tagged_stream_sptr self, unsigned int delay)
        """
        return _blocks_swig7.stream_to_tagged_stream_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(stream_to_tagged_stream_sptr self, int which) -> unsigned int"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(stream_to_tagged_stream_sptr self, int multiple)"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(stream_to_tagged_stream_sptr self) -> int"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(stream_to_tagged_stream_sptr self) -> double"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(stream_to_tagged_stream_sptr self) -> uint64_t"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(stream_to_tagged_stream_sptr self) -> uint64_t"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(stream_to_tagged_stream_sptr self) -> bool"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(stream_to_tagged_stream_sptr self) -> bool"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(stream_to_tagged_stream_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(stream_to_tagged_stream_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(stream_to_tagged_stream_sptr self, std::string level)"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(stream_to_tagged_stream_sptr self) -> std::string"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(stream_to_tagged_stream_sptr self) -> int"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(stream_to_tagged_stream_sptr self, int m)"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(stream_to_tagged_stream_sptr self)"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(stream_to_tagged_stream_sptr self) -> bool"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(stream_to_tagged_stream_sptr self, int m)"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(stream_to_tagged_stream_sptr self) -> int"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(stream_to_tagged_stream_sptr self, int i) -> long"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(stream_to_tagged_stream_sptr self, long max_output_buffer)
        set_max_output_buffer(stream_to_tagged_stream_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig7.stream_to_tagged_stream_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(stream_to_tagged_stream_sptr self, int i) -> long"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(stream_to_tagged_stream_sptr self, long min_output_buffer)
        set_min_output_buffer(stream_to_tagged_stream_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig7.stream_to_tagged_stream_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(stream_to_tagged_stream_sptr self) -> float"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(stream_to_tagged_stream_sptr self) -> float"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(stream_to_tagged_stream_sptr self) -> float"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(stream_to_tagged_stream_sptr self) -> float"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(stream_to_tagged_stream_sptr self) -> float"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(stream_to_tagged_stream_sptr self) -> float"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(stream_to_tagged_stream_sptr self, int which) -> float
        pc_input_buffers_full(stream_to_tagged_stream_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.stream_to_tagged_stream_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(stream_to_tagged_stream_sptr self, int which) -> float
        pc_input_buffers_full_avg(stream_to_tagged_stream_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.stream_to_tagged_stream_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(stream_to_tagged_stream_sptr self, int which) -> float
        pc_input_buffers_full_var(stream_to_tagged_stream_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.stream_to_tagged_stream_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(stream_to_tagged_stream_sptr self, int which) -> float
        pc_output_buffers_full(stream_to_tagged_stream_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.stream_to_tagged_stream_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(stream_to_tagged_stream_sptr self, int which) -> float
        pc_output_buffers_full_avg(stream_to_tagged_stream_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.stream_to_tagged_stream_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(stream_to_tagged_stream_sptr self, int which) -> float
        pc_output_buffers_full_var(stream_to_tagged_stream_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.stream_to_tagged_stream_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(stream_to_tagged_stream_sptr self) -> float"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(stream_to_tagged_stream_sptr self) -> float"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(stream_to_tagged_stream_sptr self) -> float"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(stream_to_tagged_stream_sptr self) -> float"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(stream_to_tagged_stream_sptr self) -> float"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(stream_to_tagged_stream_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(stream_to_tagged_stream_sptr self)"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(stream_to_tagged_stream_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(stream_to_tagged_stream_sptr self) -> int"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(stream_to_tagged_stream_sptr self) -> int"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(stream_to_tagged_stream_sptr self, int priority) -> int"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(stream_to_tagged_stream_sptr self) -> std::string"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(stream_to_tagged_stream_sptr self) -> std::string"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(stream_to_tagged_stream_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(stream_to_tagged_stream_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(stream_to_tagged_stream_sptr self) -> long"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(stream_to_tagged_stream_sptr self) -> basic_block_sptr"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(stream_to_tagged_stream_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(stream_to_tagged_stream_sptr self) -> std::string"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(stream_to_tagged_stream_sptr self, std::string name)"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(stream_to_tagged_stream_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig7.stream_to_tagged_stream_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(stream_to_tagged_stream_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(stream_to_tagged_stream_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(stream_to_tagged_stream_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig7.stream_to_tagged_stream_sptr_message_subscribers(self, which_port)

# Register stream_to_tagged_stream_sptr in _blocks_swig7:
_blocks_swig7.stream_to_tagged_stream_sptr_swigregister(stream_to_tagged_stream_sptr)


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

class stream_to_vector_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::stream_to_vector > 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__(stream_to_vector_sptr self) -> stream_to_vector_sptr
        __init__(stream_to_vector_sptr self, stream_to_vector p) -> stream_to_vector_sptr
        """
        _blocks_swig7.stream_to_vector_sptr_swiginit(self, _blocks_swig7.new_stream_to_vector_sptr(*args))

    def __deref__(self) -> "gr::blocks::stream_to_vector *":
        r"""__deref__(stream_to_vector_sptr self) -> stream_to_vector"""
        return _blocks_swig7.stream_to_vector_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig7.delete_stream_to_vector_sptr

    def make(self, itemsize: "size_t", nitems_per_block: "size_t") -> "gr::blocks::stream_to_vector::sptr":
        r"""make(stream_to_vector_sptr self, size_t itemsize, size_t nitems_per_block) -> stream_to_vector_sptr"""
        return _blocks_swig7.stream_to_vector_sptr_make(self, itemsize, nitems_per_block)

    def history(self) -> "unsigned int":
        r"""history(stream_to_vector_sptr self) -> unsigned int"""
        return _blocks_swig7.stream_to_vector_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(stream_to_vector_sptr self, int which, int delay)
        declare_sample_delay(stream_to_vector_sptr self, unsigned int delay)
        """
        return _blocks_swig7.stream_to_vector_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(stream_to_vector_sptr self, int which) -> unsigned int"""
        return _blocks_swig7.stream_to_vector_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(stream_to_vector_sptr self, int multiple)"""
        return _blocks_swig7.stream_to_vector_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(stream_to_vector_sptr self) -> int"""
        return _blocks_swig7.stream_to_vector_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(stream_to_vector_sptr self) -> double"""
        return _blocks_swig7.stream_to_vector_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(stream_to_vector_sptr self) -> uint64_t"""
        return _blocks_swig7.stream_to_vector_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(stream_to_vector_sptr self) -> uint64_t"""
        return _blocks_swig7.stream_to_vector_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(stream_to_vector_sptr self) -> bool"""
        return _blocks_swig7.stream_to_vector_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(stream_to_vector_sptr self) -> bool"""
        return _blocks_swig7.stream_to_vector_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(stream_to_vector_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig7.stream_to_vector_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(stream_to_vector_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig7.stream_to_vector_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(stream_to_vector_sptr self, std::string level)"""
        return _blocks_swig7.stream_to_vector_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(stream_to_vector_sptr self) -> std::string"""
        return _blocks_swig7.stream_to_vector_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(stream_to_vector_sptr self) -> int"""
        return _blocks_swig7.stream_to_vector_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(stream_to_vector_sptr self, int m)"""
        return _blocks_swig7.stream_to_vector_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(stream_to_vector_sptr self)"""
        return _blocks_swig7.stream_to_vector_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(stream_to_vector_sptr self) -> bool"""
        return _blocks_swig7.stream_to_vector_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(stream_to_vector_sptr self, int m)"""
        return _blocks_swig7.stream_to_vector_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(stream_to_vector_sptr self) -> int"""
        return _blocks_swig7.stream_to_vector_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(stream_to_vector_sptr self, int i) -> long"""
        return _blocks_swig7.stream_to_vector_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(stream_to_vector_sptr self, long max_output_buffer)
        set_max_output_buffer(stream_to_vector_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig7.stream_to_vector_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(stream_to_vector_sptr self, int i) -> long"""
        return _blocks_swig7.stream_to_vector_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(stream_to_vector_sptr self, long min_output_buffer)
        set_min_output_buffer(stream_to_vector_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig7.stream_to_vector_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(stream_to_vector_sptr self) -> float"""
        return _blocks_swig7.stream_to_vector_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(stream_to_vector_sptr self) -> float"""
        return _blocks_swig7.stream_to_vector_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(stream_to_vector_sptr self) -> float"""
        return _blocks_swig7.stream_to_vector_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(stream_to_vector_sptr self) -> float"""
        return _blocks_swig7.stream_to_vector_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(stream_to_vector_sptr self) -> float"""
        return _blocks_swig7.stream_to_vector_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(stream_to_vector_sptr self) -> float"""
        return _blocks_swig7.stream_to_vector_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(stream_to_vector_sptr self, int which) -> float
        pc_input_buffers_full(stream_to_vector_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.stream_to_vector_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(stream_to_vector_sptr self, int which) -> float
        pc_input_buffers_full_avg(stream_to_vector_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.stream_to_vector_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(stream_to_vector_sptr self, int which) -> float
        pc_input_buffers_full_var(stream_to_vector_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.stream_to_vector_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(stream_to_vector_sptr self, int which) -> float
        pc_output_buffers_full(stream_to_vector_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.stream_to_vector_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(stream_to_vector_sptr self, int which) -> float
        pc_output_buffers_full_avg(stream_to_vector_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.stream_to_vector_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(stream_to_vector_sptr self, int which) -> float
        pc_output_buffers_full_var(stream_to_vector_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.stream_to_vector_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(stream_to_vector_sptr self) -> float"""
        return _blocks_swig7.stream_to_vector_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(stream_to_vector_sptr self) -> float"""
        return _blocks_swig7.stream_to_vector_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(stream_to_vector_sptr self) -> float"""
        return _blocks_swig7.stream_to_vector_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(stream_to_vector_sptr self) -> float"""
        return _blocks_swig7.stream_to_vector_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(stream_to_vector_sptr self) -> float"""
        return _blocks_swig7.stream_to_vector_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(stream_to_vector_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig7.stream_to_vector_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(stream_to_vector_sptr self)"""
        return _blocks_swig7.stream_to_vector_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(stream_to_vector_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig7.stream_to_vector_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(stream_to_vector_sptr self) -> int"""
        return _blocks_swig7.stream_to_vector_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(stream_to_vector_sptr self) -> int"""
        return _blocks_swig7.stream_to_vector_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(stream_to_vector_sptr self, int priority) -> int"""
        return _blocks_swig7.stream_to_vector_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(stream_to_vector_sptr self) -> std::string"""
        return _blocks_swig7.stream_to_vector_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(stream_to_vector_sptr self) -> std::string"""
        return _blocks_swig7.stream_to_vector_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(stream_to_vector_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.stream_to_vector_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(stream_to_vector_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.stream_to_vector_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(stream_to_vector_sptr self) -> long"""
        return _blocks_swig7.stream_to_vector_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(stream_to_vector_sptr self) -> basic_block_sptr"""
        return _blocks_swig7.stream_to_vector_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(stream_to_vector_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig7.stream_to_vector_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(stream_to_vector_sptr self) -> std::string"""
        return _blocks_swig7.stream_to_vector_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(stream_to_vector_sptr self, std::string name)"""
        return _blocks_swig7.stream_to_vector_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(stream_to_vector_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig7.stream_to_vector_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(stream_to_vector_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig7.stream_to_vector_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(stream_to_vector_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig7.stream_to_vector_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(stream_to_vector_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig7.stream_to_vector_sptr_message_subscribers(self, which_port)

# Register stream_to_vector_sptr in _blocks_swig7:
_blocks_swig7.stream_to_vector_sptr_swigregister(stream_to_vector_sptr)


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

class streams_to_stream_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::streams_to_stream > 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__(streams_to_stream_sptr self) -> streams_to_stream_sptr
        __init__(streams_to_stream_sptr self, streams_to_stream p) -> streams_to_stream_sptr
        """
        _blocks_swig7.streams_to_stream_sptr_swiginit(self, _blocks_swig7.new_streams_to_stream_sptr(*args))

    def __deref__(self) -> "gr::blocks::streams_to_stream *":
        r"""__deref__(streams_to_stream_sptr self) -> streams_to_stream"""
        return _blocks_swig7.streams_to_stream_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig7.delete_streams_to_stream_sptr

    def make(self, itemsize: "size_t", nstreams: "size_t") -> "gr::blocks::streams_to_stream::sptr":
        r"""make(streams_to_stream_sptr self, size_t itemsize, size_t nstreams) -> streams_to_stream_sptr"""
        return _blocks_swig7.streams_to_stream_sptr_make(self, itemsize, nstreams)

    def history(self) -> "unsigned int":
        r"""history(streams_to_stream_sptr self) -> unsigned int"""
        return _blocks_swig7.streams_to_stream_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(streams_to_stream_sptr self, int which, int delay)
        declare_sample_delay(streams_to_stream_sptr self, unsigned int delay)
        """
        return _blocks_swig7.streams_to_stream_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(streams_to_stream_sptr self, int which) -> unsigned int"""
        return _blocks_swig7.streams_to_stream_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(streams_to_stream_sptr self, int multiple)"""
        return _blocks_swig7.streams_to_stream_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(streams_to_stream_sptr self) -> int"""
        return _blocks_swig7.streams_to_stream_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(streams_to_stream_sptr self) -> double"""
        return _blocks_swig7.streams_to_stream_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(streams_to_stream_sptr self) -> uint64_t"""
        return _blocks_swig7.streams_to_stream_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(streams_to_stream_sptr self) -> uint64_t"""
        return _blocks_swig7.streams_to_stream_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(streams_to_stream_sptr self) -> bool"""
        return _blocks_swig7.streams_to_stream_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(streams_to_stream_sptr self) -> bool"""
        return _blocks_swig7.streams_to_stream_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(streams_to_stream_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig7.streams_to_stream_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(streams_to_stream_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig7.streams_to_stream_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(streams_to_stream_sptr self, std::string level)"""
        return _blocks_swig7.streams_to_stream_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(streams_to_stream_sptr self) -> std::string"""
        return _blocks_swig7.streams_to_stream_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(streams_to_stream_sptr self) -> int"""
        return _blocks_swig7.streams_to_stream_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(streams_to_stream_sptr self, int m)"""
        return _blocks_swig7.streams_to_stream_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(streams_to_stream_sptr self)"""
        return _blocks_swig7.streams_to_stream_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(streams_to_stream_sptr self) -> bool"""
        return _blocks_swig7.streams_to_stream_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(streams_to_stream_sptr self, int m)"""
        return _blocks_swig7.streams_to_stream_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(streams_to_stream_sptr self) -> int"""
        return _blocks_swig7.streams_to_stream_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(streams_to_stream_sptr self, int i) -> long"""
        return _blocks_swig7.streams_to_stream_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(streams_to_stream_sptr self, long max_output_buffer)
        set_max_output_buffer(streams_to_stream_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig7.streams_to_stream_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(streams_to_stream_sptr self, int i) -> long"""
        return _blocks_swig7.streams_to_stream_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(streams_to_stream_sptr self, long min_output_buffer)
        set_min_output_buffer(streams_to_stream_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig7.streams_to_stream_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(streams_to_stream_sptr self) -> float"""
        return _blocks_swig7.streams_to_stream_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(streams_to_stream_sptr self) -> float"""
        return _blocks_swig7.streams_to_stream_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(streams_to_stream_sptr self) -> float"""
        return _blocks_swig7.streams_to_stream_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(streams_to_stream_sptr self) -> float"""
        return _blocks_swig7.streams_to_stream_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(streams_to_stream_sptr self) -> float"""
        return _blocks_swig7.streams_to_stream_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(streams_to_stream_sptr self) -> float"""
        return _blocks_swig7.streams_to_stream_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(streams_to_stream_sptr self, int which) -> float
        pc_input_buffers_full(streams_to_stream_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.streams_to_stream_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(streams_to_stream_sptr self, int which) -> float
        pc_input_buffers_full_avg(streams_to_stream_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.streams_to_stream_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(streams_to_stream_sptr self, int which) -> float
        pc_input_buffers_full_var(streams_to_stream_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.streams_to_stream_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(streams_to_stream_sptr self, int which) -> float
        pc_output_buffers_full(streams_to_stream_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.streams_to_stream_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(streams_to_stream_sptr self, int which) -> float
        pc_output_buffers_full_avg(streams_to_stream_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.streams_to_stream_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(streams_to_stream_sptr self, int which) -> float
        pc_output_buffers_full_var(streams_to_stream_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.streams_to_stream_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(streams_to_stream_sptr self) -> float"""
        return _blocks_swig7.streams_to_stream_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(streams_to_stream_sptr self) -> float"""
        return _blocks_swig7.streams_to_stream_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(streams_to_stream_sptr self) -> float"""
        return _blocks_swig7.streams_to_stream_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(streams_to_stream_sptr self) -> float"""
        return _blocks_swig7.streams_to_stream_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(streams_to_stream_sptr self) -> float"""
        return _blocks_swig7.streams_to_stream_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(streams_to_stream_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig7.streams_to_stream_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(streams_to_stream_sptr self)"""
        return _blocks_swig7.streams_to_stream_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(streams_to_stream_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig7.streams_to_stream_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(streams_to_stream_sptr self) -> int"""
        return _blocks_swig7.streams_to_stream_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(streams_to_stream_sptr self) -> int"""
        return _blocks_swig7.streams_to_stream_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(streams_to_stream_sptr self, int priority) -> int"""
        return _blocks_swig7.streams_to_stream_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(streams_to_stream_sptr self) -> std::string"""
        return _blocks_swig7.streams_to_stream_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(streams_to_stream_sptr self) -> std::string"""
        return _blocks_swig7.streams_to_stream_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(streams_to_stream_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.streams_to_stream_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(streams_to_stream_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.streams_to_stream_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(streams_to_stream_sptr self) -> long"""
        return _blocks_swig7.streams_to_stream_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(streams_to_stream_sptr self) -> basic_block_sptr"""
        return _blocks_swig7.streams_to_stream_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(streams_to_stream_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig7.streams_to_stream_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(streams_to_stream_sptr self) -> std::string"""
        return _blocks_swig7.streams_to_stream_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(streams_to_stream_sptr self, std::string name)"""
        return _blocks_swig7.streams_to_stream_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(streams_to_stream_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig7.streams_to_stream_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(streams_to_stream_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig7.streams_to_stream_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(streams_to_stream_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig7.streams_to_stream_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(streams_to_stream_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig7.streams_to_stream_sptr_message_subscribers(self, which_port)

# Register streams_to_stream_sptr in _blocks_swig7:
_blocks_swig7.streams_to_stream_sptr_swigregister(streams_to_stream_sptr)


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

class streams_to_vector_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::streams_to_vector > 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__(streams_to_vector_sptr self) -> streams_to_vector_sptr
        __init__(streams_to_vector_sptr self, streams_to_vector p) -> streams_to_vector_sptr
        """
        _blocks_swig7.streams_to_vector_sptr_swiginit(self, _blocks_swig7.new_streams_to_vector_sptr(*args))

    def __deref__(self) -> "gr::blocks::streams_to_vector *":
        r"""__deref__(streams_to_vector_sptr self) -> streams_to_vector"""
        return _blocks_swig7.streams_to_vector_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig7.delete_streams_to_vector_sptr

    def make(self, itemsize: "size_t", nstreams: "size_t") -> "gr::blocks::streams_to_vector::sptr":
        r"""make(streams_to_vector_sptr self, size_t itemsize, size_t nstreams) -> streams_to_vector_sptr"""
        return _blocks_swig7.streams_to_vector_sptr_make(self, itemsize, nstreams)

    def history(self) -> "unsigned int":
        r"""history(streams_to_vector_sptr self) -> unsigned int"""
        return _blocks_swig7.streams_to_vector_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(streams_to_vector_sptr self, int which, int delay)
        declare_sample_delay(streams_to_vector_sptr self, unsigned int delay)
        """
        return _blocks_swig7.streams_to_vector_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(streams_to_vector_sptr self, int which) -> unsigned int"""
        return _blocks_swig7.streams_to_vector_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(streams_to_vector_sptr self, int multiple)"""
        return _blocks_swig7.streams_to_vector_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(streams_to_vector_sptr self) -> int"""
        return _blocks_swig7.streams_to_vector_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(streams_to_vector_sptr self) -> double"""
        return _blocks_swig7.streams_to_vector_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(streams_to_vector_sptr self) -> uint64_t"""
        return _blocks_swig7.streams_to_vector_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(streams_to_vector_sptr self) -> uint64_t"""
        return _blocks_swig7.streams_to_vector_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(streams_to_vector_sptr self) -> bool"""
        return _blocks_swig7.streams_to_vector_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(streams_to_vector_sptr self) -> bool"""
        return _blocks_swig7.streams_to_vector_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(streams_to_vector_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig7.streams_to_vector_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(streams_to_vector_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig7.streams_to_vector_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(streams_to_vector_sptr self, std::string level)"""
        return _blocks_swig7.streams_to_vector_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(streams_to_vector_sptr self) -> std::string"""
        return _blocks_swig7.streams_to_vector_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(streams_to_vector_sptr self) -> int"""
        return _blocks_swig7.streams_to_vector_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(streams_to_vector_sptr self, int m)"""
        return _blocks_swig7.streams_to_vector_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(streams_to_vector_sptr self)"""
        return _blocks_swig7.streams_to_vector_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(streams_to_vector_sptr self) -> bool"""
        return _blocks_swig7.streams_to_vector_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(streams_to_vector_sptr self, int m)"""
        return _blocks_swig7.streams_to_vector_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(streams_to_vector_sptr self) -> int"""
        return _blocks_swig7.streams_to_vector_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(streams_to_vector_sptr self, int i) -> long"""
        return _blocks_swig7.streams_to_vector_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(streams_to_vector_sptr self, long max_output_buffer)
        set_max_output_buffer(streams_to_vector_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig7.streams_to_vector_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(streams_to_vector_sptr self, int i) -> long"""
        return _blocks_swig7.streams_to_vector_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(streams_to_vector_sptr self, long min_output_buffer)
        set_min_output_buffer(streams_to_vector_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig7.streams_to_vector_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(streams_to_vector_sptr self) -> float"""
        return _blocks_swig7.streams_to_vector_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(streams_to_vector_sptr self) -> float"""
        return _blocks_swig7.streams_to_vector_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(streams_to_vector_sptr self) -> float"""
        return _blocks_swig7.streams_to_vector_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(streams_to_vector_sptr self) -> float"""
        return _blocks_swig7.streams_to_vector_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(streams_to_vector_sptr self) -> float"""
        return _blocks_swig7.streams_to_vector_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(streams_to_vector_sptr self) -> float"""
        return _blocks_swig7.streams_to_vector_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(streams_to_vector_sptr self, int which) -> float
        pc_input_buffers_full(streams_to_vector_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.streams_to_vector_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(streams_to_vector_sptr self, int which) -> float
        pc_input_buffers_full_avg(streams_to_vector_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.streams_to_vector_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(streams_to_vector_sptr self, int which) -> float
        pc_input_buffers_full_var(streams_to_vector_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.streams_to_vector_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(streams_to_vector_sptr self, int which) -> float
        pc_output_buffers_full(streams_to_vector_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.streams_to_vector_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(streams_to_vector_sptr self, int which) -> float
        pc_output_buffers_full_avg(streams_to_vector_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.streams_to_vector_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(streams_to_vector_sptr self, int which) -> float
        pc_output_buffers_full_var(streams_to_vector_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.streams_to_vector_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(streams_to_vector_sptr self) -> float"""
        return _blocks_swig7.streams_to_vector_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(streams_to_vector_sptr self) -> float"""
        return _blocks_swig7.streams_to_vector_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(streams_to_vector_sptr self) -> float"""
        return _blocks_swig7.streams_to_vector_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(streams_to_vector_sptr self) -> float"""
        return _blocks_swig7.streams_to_vector_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(streams_to_vector_sptr self) -> float"""
        return _blocks_swig7.streams_to_vector_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(streams_to_vector_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig7.streams_to_vector_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(streams_to_vector_sptr self)"""
        return _blocks_swig7.streams_to_vector_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(streams_to_vector_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig7.streams_to_vector_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(streams_to_vector_sptr self) -> int"""
        return _blocks_swig7.streams_to_vector_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(streams_to_vector_sptr self) -> int"""
        return _blocks_swig7.streams_to_vector_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(streams_to_vector_sptr self, int priority) -> int"""
        return _blocks_swig7.streams_to_vector_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(streams_to_vector_sptr self) -> std::string"""
        return _blocks_swig7.streams_to_vector_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(streams_to_vector_sptr self) -> std::string"""
        return _blocks_swig7.streams_to_vector_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(streams_to_vector_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.streams_to_vector_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(streams_to_vector_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.streams_to_vector_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(streams_to_vector_sptr self) -> long"""
        return _blocks_swig7.streams_to_vector_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(streams_to_vector_sptr self) -> basic_block_sptr"""
        return _blocks_swig7.streams_to_vector_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(streams_to_vector_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig7.streams_to_vector_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(streams_to_vector_sptr self) -> std::string"""
        return _blocks_swig7.streams_to_vector_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(streams_to_vector_sptr self, std::string name)"""
        return _blocks_swig7.streams_to_vector_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(streams_to_vector_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig7.streams_to_vector_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(streams_to_vector_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig7.streams_to_vector_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(streams_to_vector_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig7.streams_to_vector_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(streams_to_vector_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig7.streams_to_vector_sptr_message_subscribers(self, which_port)

# Register streams_to_vector_sptr in _blocks_swig7:
_blocks_swig7.streams_to_vector_sptr_swigregister(streams_to_vector_sptr)


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

class tag_debug_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::tag_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__(tag_debug_sptr self) -> tag_debug_sptr
        __init__(tag_debug_sptr self, tag_debug p) -> tag_debug_sptr
        """
        _blocks_swig7.tag_debug_sptr_swiginit(self, _blocks_swig7.new_tag_debug_sptr(*args))

    def __deref__(self) -> "gr::blocks::tag_debug *":
        r"""__deref__(tag_debug_sptr self) -> tag_debug"""
        return _blocks_swig7.tag_debug_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig7.delete_tag_debug_sptr

    def make(self, *args, **kwargs) -> "gr::blocks::tag_debug::sptr":
        r"""make(tag_debug_sptr self, size_t sizeof_stream_item, std::string const & name, std::string const & key_filter="") -> tag_debug_sptr"""
        return _blocks_swig7.tag_debug_sptr_make(self, *args, **kwargs)

    def current_tags(self) -> "std::vector< gr::tag_t,std::allocator< gr::tag_t > >":
        r"""current_tags(tag_debug_sptr self) -> tags_vector_t"""
        return _blocks_swig7.tag_debug_sptr_current_tags(self)

    def num_tags(self) -> "int":
        r"""num_tags(tag_debug_sptr self) -> int"""
        return _blocks_swig7.tag_debug_sptr_num_tags(self)

    def set_display(self, d: "bool") -> "void":
        r"""set_display(tag_debug_sptr self, bool d)"""
        return _blocks_swig7.tag_debug_sptr_set_display(self, d)

    def set_key_filter(self, key_filter: "std::string const &") -> "void":
        r"""set_key_filter(tag_debug_sptr self, std::string const & key_filter)"""
        return _blocks_swig7.tag_debug_sptr_set_key_filter(self, key_filter)

    def key_filter(self) -> "std::string":
        r"""key_filter(tag_debug_sptr self) -> std::string"""
        return _blocks_swig7.tag_debug_sptr_key_filter(self)

    def history(self) -> "unsigned int":
        r"""history(tag_debug_sptr self) -> unsigned int"""
        return _blocks_swig7.tag_debug_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(tag_debug_sptr self, int which, int delay)
        declare_sample_delay(tag_debug_sptr self, unsigned int delay)
        """
        return _blocks_swig7.tag_debug_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(tag_debug_sptr self, int which) -> unsigned int"""
        return _blocks_swig7.tag_debug_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(tag_debug_sptr self, int multiple)"""
        return _blocks_swig7.tag_debug_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(tag_debug_sptr self) -> int"""
        return _blocks_swig7.tag_debug_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(tag_debug_sptr self) -> double"""
        return _blocks_swig7.tag_debug_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(tag_debug_sptr self) -> uint64_t"""
        return _blocks_swig7.tag_debug_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(tag_debug_sptr self) -> uint64_t"""
        return _blocks_swig7.tag_debug_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(tag_debug_sptr self) -> bool"""
        return _blocks_swig7.tag_debug_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(tag_debug_sptr self) -> bool"""
        return _blocks_swig7.tag_debug_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(tag_debug_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig7.tag_debug_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(tag_debug_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig7.tag_debug_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(tag_debug_sptr self, std::string level)"""
        return _blocks_swig7.tag_debug_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(tag_debug_sptr self) -> std::string"""
        return _blocks_swig7.tag_debug_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(tag_debug_sptr self) -> int"""
        return _blocks_swig7.tag_debug_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(tag_debug_sptr self, int m)"""
        return _blocks_swig7.tag_debug_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(tag_debug_sptr self)"""
        return _blocks_swig7.tag_debug_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(tag_debug_sptr self) -> bool"""
        return _blocks_swig7.tag_debug_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(tag_debug_sptr self, int m)"""
        return _blocks_swig7.tag_debug_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(tag_debug_sptr self) -> int"""
        return _blocks_swig7.tag_debug_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(tag_debug_sptr self, int i) -> long"""
        return _blocks_swig7.tag_debug_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(tag_debug_sptr self, long max_output_buffer)
        set_max_output_buffer(tag_debug_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig7.tag_debug_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(tag_debug_sptr self, int i) -> long"""
        return _blocks_swig7.tag_debug_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(tag_debug_sptr self, long min_output_buffer)
        set_min_output_buffer(tag_debug_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig7.tag_debug_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(tag_debug_sptr self) -> float"""
        return _blocks_swig7.tag_debug_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(tag_debug_sptr self) -> float"""
        return _blocks_swig7.tag_debug_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(tag_debug_sptr self) -> float"""
        return _blocks_swig7.tag_debug_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(tag_debug_sptr self) -> float"""
        return _blocks_swig7.tag_debug_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(tag_debug_sptr self) -> float"""
        return _blocks_swig7.tag_debug_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(tag_debug_sptr self) -> float"""
        return _blocks_swig7.tag_debug_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(tag_debug_sptr self, int which) -> float
        pc_input_buffers_full(tag_debug_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tag_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(tag_debug_sptr self, int which) -> float
        pc_input_buffers_full_avg(tag_debug_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tag_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(tag_debug_sptr self, int which) -> float
        pc_input_buffers_full_var(tag_debug_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tag_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(tag_debug_sptr self, int which) -> float
        pc_output_buffers_full(tag_debug_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tag_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(tag_debug_sptr self, int which) -> float
        pc_output_buffers_full_avg(tag_debug_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tag_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(tag_debug_sptr self, int which) -> float
        pc_output_buffers_full_var(tag_debug_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tag_debug_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(tag_debug_sptr self) -> float"""
        return _blocks_swig7.tag_debug_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(tag_debug_sptr self) -> float"""
        return _blocks_swig7.tag_debug_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(tag_debug_sptr self) -> float"""
        return _blocks_swig7.tag_debug_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(tag_debug_sptr self) -> float"""
        return _blocks_swig7.tag_debug_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(tag_debug_sptr self) -> float"""
        return _blocks_swig7.tag_debug_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(tag_debug_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig7.tag_debug_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(tag_debug_sptr self)"""
        return _blocks_swig7.tag_debug_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(tag_debug_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig7.tag_debug_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(tag_debug_sptr self) -> int"""
        return _blocks_swig7.tag_debug_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(tag_debug_sptr self) -> int"""
        return _blocks_swig7.tag_debug_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(tag_debug_sptr self, int priority) -> int"""
        return _blocks_swig7.tag_debug_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(tag_debug_sptr self) -> std::string"""
        return _blocks_swig7.tag_debug_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(tag_debug_sptr self) -> std::string"""
        return _blocks_swig7.tag_debug_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(tag_debug_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.tag_debug_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(tag_debug_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.tag_debug_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(tag_debug_sptr self) -> long"""
        return _blocks_swig7.tag_debug_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(tag_debug_sptr self) -> basic_block_sptr"""
        return _blocks_swig7.tag_debug_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(tag_debug_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig7.tag_debug_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(tag_debug_sptr self) -> std::string"""
        return _blocks_swig7.tag_debug_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(tag_debug_sptr self, std::string name)"""
        return _blocks_swig7.tag_debug_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(tag_debug_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig7.tag_debug_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(tag_debug_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig7.tag_debug_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(tag_debug_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig7.tag_debug_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(tag_debug_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig7.tag_debug_sptr_message_subscribers(self, which_port)

# Register tag_debug_sptr in _blocks_swig7:
_blocks_swig7.tag_debug_sptr_swigregister(tag_debug_sptr)


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

class tagged_file_sink_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::tagged_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__(tagged_file_sink_sptr self) -> tagged_file_sink_sptr
        __init__(tagged_file_sink_sptr self, tagged_file_sink p) -> tagged_file_sink_sptr
        """
        _blocks_swig7.tagged_file_sink_sptr_swiginit(self, _blocks_swig7.new_tagged_file_sink_sptr(*args))

    def __deref__(self) -> "gr::blocks::tagged_file_sink *":
        r"""__deref__(tagged_file_sink_sptr self) -> tagged_file_sink"""
        return _blocks_swig7.tagged_file_sink_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig7.delete_tagged_file_sink_sptr

    def make(self, itemsize: "size_t", samp_rate: "double") -> "gr::blocks::tagged_file_sink::sptr":
        r"""make(tagged_file_sink_sptr self, size_t itemsize, double samp_rate) -> tagged_file_sink_sptr"""
        return _blocks_swig7.tagged_file_sink_sptr_make(self, itemsize, samp_rate)

    def history(self) -> "unsigned int":
        r"""history(tagged_file_sink_sptr self) -> unsigned int"""
        return _blocks_swig7.tagged_file_sink_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(tagged_file_sink_sptr self, int which, int delay)
        declare_sample_delay(tagged_file_sink_sptr self, unsigned int delay)
        """
        return _blocks_swig7.tagged_file_sink_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(tagged_file_sink_sptr self, int which) -> unsigned int"""
        return _blocks_swig7.tagged_file_sink_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(tagged_file_sink_sptr self, int multiple)"""
        return _blocks_swig7.tagged_file_sink_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(tagged_file_sink_sptr self) -> int"""
        return _blocks_swig7.tagged_file_sink_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(tagged_file_sink_sptr self) -> double"""
        return _blocks_swig7.tagged_file_sink_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(tagged_file_sink_sptr self) -> uint64_t"""
        return _blocks_swig7.tagged_file_sink_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(tagged_file_sink_sptr self) -> uint64_t"""
        return _blocks_swig7.tagged_file_sink_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(tagged_file_sink_sptr self) -> bool"""
        return _blocks_swig7.tagged_file_sink_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(tagged_file_sink_sptr self) -> bool"""
        return _blocks_swig7.tagged_file_sink_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(tagged_file_sink_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig7.tagged_file_sink_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(tagged_file_sink_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig7.tagged_file_sink_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(tagged_file_sink_sptr self, std::string level)"""
        return _blocks_swig7.tagged_file_sink_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(tagged_file_sink_sptr self) -> std::string"""
        return _blocks_swig7.tagged_file_sink_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(tagged_file_sink_sptr self) -> int"""
        return _blocks_swig7.tagged_file_sink_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(tagged_file_sink_sptr self, int m)"""
        return _blocks_swig7.tagged_file_sink_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(tagged_file_sink_sptr self)"""
        return _blocks_swig7.tagged_file_sink_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(tagged_file_sink_sptr self) -> bool"""
        return _blocks_swig7.tagged_file_sink_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(tagged_file_sink_sptr self, int m)"""
        return _blocks_swig7.tagged_file_sink_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(tagged_file_sink_sptr self) -> int"""
        return _blocks_swig7.tagged_file_sink_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(tagged_file_sink_sptr self, int i) -> long"""
        return _blocks_swig7.tagged_file_sink_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(tagged_file_sink_sptr self, long max_output_buffer)
        set_max_output_buffer(tagged_file_sink_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig7.tagged_file_sink_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(tagged_file_sink_sptr self, int i) -> long"""
        return _blocks_swig7.tagged_file_sink_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(tagged_file_sink_sptr self, long min_output_buffer)
        set_min_output_buffer(tagged_file_sink_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig7.tagged_file_sink_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(tagged_file_sink_sptr self) -> float"""
        return _blocks_swig7.tagged_file_sink_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(tagged_file_sink_sptr self) -> float"""
        return _blocks_swig7.tagged_file_sink_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(tagged_file_sink_sptr self) -> float"""
        return _blocks_swig7.tagged_file_sink_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(tagged_file_sink_sptr self) -> float"""
        return _blocks_swig7.tagged_file_sink_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(tagged_file_sink_sptr self) -> float"""
        return _blocks_swig7.tagged_file_sink_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(tagged_file_sink_sptr self) -> float"""
        return _blocks_swig7.tagged_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(tagged_file_sink_sptr self, int which) -> float
        pc_input_buffers_full(tagged_file_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tagged_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(tagged_file_sink_sptr self, int which) -> float
        pc_input_buffers_full_avg(tagged_file_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tagged_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(tagged_file_sink_sptr self, int which) -> float
        pc_input_buffers_full_var(tagged_file_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tagged_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(tagged_file_sink_sptr self, int which) -> float
        pc_output_buffers_full(tagged_file_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tagged_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(tagged_file_sink_sptr self, int which) -> float
        pc_output_buffers_full_avg(tagged_file_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tagged_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(tagged_file_sink_sptr self, int which) -> float
        pc_output_buffers_full_var(tagged_file_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tagged_file_sink_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(tagged_file_sink_sptr self) -> float"""
        return _blocks_swig7.tagged_file_sink_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(tagged_file_sink_sptr self) -> float"""
        return _blocks_swig7.tagged_file_sink_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(tagged_file_sink_sptr self) -> float"""
        return _blocks_swig7.tagged_file_sink_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(tagged_file_sink_sptr self) -> float"""
        return _blocks_swig7.tagged_file_sink_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(tagged_file_sink_sptr self) -> float"""
        return _blocks_swig7.tagged_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(tagged_file_sink_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig7.tagged_file_sink_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(tagged_file_sink_sptr self)"""
        return _blocks_swig7.tagged_file_sink_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(tagged_file_sink_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig7.tagged_file_sink_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(tagged_file_sink_sptr self) -> int"""
        return _blocks_swig7.tagged_file_sink_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(tagged_file_sink_sptr self) -> int"""
        return _blocks_swig7.tagged_file_sink_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(tagged_file_sink_sptr self, int priority) -> int"""
        return _blocks_swig7.tagged_file_sink_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(tagged_file_sink_sptr self) -> std::string"""
        return _blocks_swig7.tagged_file_sink_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(tagged_file_sink_sptr self) -> std::string"""
        return _blocks_swig7.tagged_file_sink_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(tagged_file_sink_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.tagged_file_sink_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(tagged_file_sink_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.tagged_file_sink_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(tagged_file_sink_sptr self) -> long"""
        return _blocks_swig7.tagged_file_sink_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(tagged_file_sink_sptr self) -> basic_block_sptr"""
        return _blocks_swig7.tagged_file_sink_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(tagged_file_sink_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig7.tagged_file_sink_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(tagged_file_sink_sptr self) -> std::string"""
        return _blocks_swig7.tagged_file_sink_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(tagged_file_sink_sptr self, std::string name)"""
        return _blocks_swig7.tagged_file_sink_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(tagged_file_sink_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig7.tagged_file_sink_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(tagged_file_sink_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig7.tagged_file_sink_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(tagged_file_sink_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig7.tagged_file_sink_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(tagged_file_sink_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig7.tagged_file_sink_sptr_message_subscribers(self, which_port)

# Register tagged_file_sink_sptr in _blocks_swig7:
_blocks_swig7.tagged_file_sink_sptr_swigregister(tagged_file_sink_sptr)


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

class tsb_vector_sink_b(object):
    r"""Proxy of C++ gr::blocks::tsb_vector_sink< std::uint8_t > class."""

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

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

    def reset(self) -> "void":
        r"""reset(tsb_vector_sink_b self)"""
        return _blocks_swig7.tsb_vector_sink_b_reset(self)

    def data(self) -> "std::vector< std::vector< std::uint8_t,std::allocator< std::uint8_t > >,std::allocator< std::vector< std::uint8_t,std::allocator< std::uint8_t > > > >":
        r"""data(tsb_vector_sink_b self) -> std::vector< std::vector< std::uint8_t,std::allocator< std::uint8_t > >,std::allocator< std::vector< std::uint8_t,std::allocator< std::uint8_t > > > >"""
        return _blocks_swig7.tsb_vector_sink_b_data(self)

    def tags(self) -> "std::vector< gr::tag_t,std::allocator< gr::tag_t > >":
        r"""tags(tsb_vector_sink_b self) -> tags_vector_t"""
        return _blocks_swig7.tsb_vector_sink_b_tags(self)

    @staticmethod
    def make(*args, **kwargs) -> "gr::blocks::tsb_vector_sink< unsigned char >::sptr":
        r"""make(unsigned int vlen=1, std::string const & tsb_key="ts_last") -> tsb_vector_sink_b_sptr"""
        return _blocks_swig7.tsb_vector_sink_b_make(*args, **kwargs)
    __swig_destroy__ = _blocks_swig7.delete_tsb_vector_sink_b

# Register tsb_vector_sink_b in _blocks_swig7:
_blocks_swig7.tsb_vector_sink_b_swigregister(tsb_vector_sink_b)

def tsb_vector_sink_b_make(*args, **kwargs) -> "gr::blocks::tsb_vector_sink< unsigned char >::sptr":
    r"""tsb_vector_sink_b_make(unsigned int vlen=1, std::string const & tsb_key="ts_last") -> tsb_vector_sink_b_sptr"""
    return _blocks_swig7.tsb_vector_sink_b_make(*args, **kwargs)

class tsb_vector_sink_b_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::tsb_vector_sink< std::uint8_t > > class."""

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

    def __init__(self, *args):
        r"""
        __init__(tsb_vector_sink_b_sptr self) -> tsb_vector_sink_b_sptr
        __init__(tsb_vector_sink_b_sptr self, tsb_vector_sink_b p) -> tsb_vector_sink_b_sptr
        """
        _blocks_swig7.tsb_vector_sink_b_sptr_swiginit(self, _blocks_swig7.new_tsb_vector_sink_b_sptr(*args))

    def __deref__(self) -> "gr::blocks::tsb_vector_sink< std::uint8_t > *":
        r"""__deref__(tsb_vector_sink_b_sptr self) -> tsb_vector_sink_b"""
        return _blocks_swig7.tsb_vector_sink_b_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig7.delete_tsb_vector_sink_b_sptr

    def reset(self) -> "void":
        r"""reset(tsb_vector_sink_b_sptr self)"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_reset(self)

    def data(self) -> "std::vector< std::vector< std::uint8_t,std::allocator< std::uint8_t > >,std::allocator< std::vector< std::uint8_t,std::allocator< std::uint8_t > > > >":
        r"""data(tsb_vector_sink_b_sptr self) -> std::vector< std::vector< std::uint8_t,std::allocator< std::uint8_t > >,std::allocator< std::vector< std::uint8_t,std::allocator< std::uint8_t > > > >"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_data(self)

    def tags(self) -> "std::vector< gr::tag_t,std::allocator< gr::tag_t > >":
        r"""tags(tsb_vector_sink_b_sptr self) -> tags_vector_t"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_tags(self)

    def make(self, *args, **kwargs) -> "gr::blocks::tsb_vector_sink< unsigned char >::sptr":
        r"""make(tsb_vector_sink_b_sptr self, unsigned int vlen=1, std::string const & tsb_key="ts_last") -> tsb_vector_sink_b_sptr"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_make(self, *args, **kwargs)

    def history(self) -> "unsigned int":
        r"""history(tsb_vector_sink_b_sptr self) -> unsigned int"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(tsb_vector_sink_b_sptr self, int which, int delay)
        declare_sample_delay(tsb_vector_sink_b_sptr self, unsigned int delay)
        """
        return _blocks_swig7.tsb_vector_sink_b_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(tsb_vector_sink_b_sptr self, int which) -> unsigned int"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(tsb_vector_sink_b_sptr self, int multiple)"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(tsb_vector_sink_b_sptr self) -> int"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(tsb_vector_sink_b_sptr self) -> double"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(tsb_vector_sink_b_sptr self) -> uint64_t"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(tsb_vector_sink_b_sptr self) -> uint64_t"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(tsb_vector_sink_b_sptr self) -> bool"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(tsb_vector_sink_b_sptr self) -> bool"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(tsb_vector_sink_b_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(tsb_vector_sink_b_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(tsb_vector_sink_b_sptr self, std::string level)"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(tsb_vector_sink_b_sptr self) -> std::string"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(tsb_vector_sink_b_sptr self) -> int"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(tsb_vector_sink_b_sptr self, int m)"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(tsb_vector_sink_b_sptr self)"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(tsb_vector_sink_b_sptr self) -> bool"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(tsb_vector_sink_b_sptr self, int m)"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(tsb_vector_sink_b_sptr self) -> int"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(tsb_vector_sink_b_sptr self, int i) -> long"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(tsb_vector_sink_b_sptr self, long max_output_buffer)
        set_max_output_buffer(tsb_vector_sink_b_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig7.tsb_vector_sink_b_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(tsb_vector_sink_b_sptr self, int i) -> long"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(tsb_vector_sink_b_sptr self, long min_output_buffer)
        set_min_output_buffer(tsb_vector_sink_b_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig7.tsb_vector_sink_b_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(tsb_vector_sink_b_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(tsb_vector_sink_b_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(tsb_vector_sink_b_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(tsb_vector_sink_b_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(tsb_vector_sink_b_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(tsb_vector_sink_b_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(tsb_vector_sink_b_sptr self, int which) -> float
        pc_input_buffers_full(tsb_vector_sink_b_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tsb_vector_sink_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(tsb_vector_sink_b_sptr self, int which) -> float
        pc_input_buffers_full_avg(tsb_vector_sink_b_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tsb_vector_sink_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(tsb_vector_sink_b_sptr self, int which) -> float
        pc_input_buffers_full_var(tsb_vector_sink_b_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tsb_vector_sink_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(tsb_vector_sink_b_sptr self, int which) -> float
        pc_output_buffers_full(tsb_vector_sink_b_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tsb_vector_sink_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(tsb_vector_sink_b_sptr self, int which) -> float
        pc_output_buffers_full_avg(tsb_vector_sink_b_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tsb_vector_sink_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(tsb_vector_sink_b_sptr self, int which) -> float
        pc_output_buffers_full_var(tsb_vector_sink_b_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tsb_vector_sink_b_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(tsb_vector_sink_b_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(tsb_vector_sink_b_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(tsb_vector_sink_b_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(tsb_vector_sink_b_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(tsb_vector_sink_b_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(tsb_vector_sink_b_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(tsb_vector_sink_b_sptr self)"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(tsb_vector_sink_b_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(tsb_vector_sink_b_sptr self) -> int"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(tsb_vector_sink_b_sptr self) -> int"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(tsb_vector_sink_b_sptr self, int priority) -> int"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(tsb_vector_sink_b_sptr self) -> std::string"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(tsb_vector_sink_b_sptr self) -> std::string"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(tsb_vector_sink_b_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(tsb_vector_sink_b_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(tsb_vector_sink_b_sptr self) -> long"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(tsb_vector_sink_b_sptr self) -> basic_block_sptr"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(tsb_vector_sink_b_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(tsb_vector_sink_b_sptr self) -> std::string"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(tsb_vector_sink_b_sptr self, std::string name)"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(tsb_vector_sink_b_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig7.tsb_vector_sink_b_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(tsb_vector_sink_b_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(tsb_vector_sink_b_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(tsb_vector_sink_b_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig7.tsb_vector_sink_b_sptr_message_subscribers(self, which_port)

# Register tsb_vector_sink_b_sptr in _blocks_swig7:
_blocks_swig7.tsb_vector_sink_b_sptr_swigregister(tsb_vector_sink_b_sptr)


tsb_vector_sink_b_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
tsb_vector_sink_b = tsb_vector_sink_b.make

class tsb_vector_sink_c(object):
    r"""Proxy of C++ gr::blocks::tsb_vector_sink< gr_complex > class."""

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

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

    def reset(self) -> "void":
        r"""reset(tsb_vector_sink_c self)"""
        return _blocks_swig7.tsb_vector_sink_c_reset(self)

    def data(self) -> "std::vector< std::vector< std::complex< float >,std::allocator< std::complex< float > > >,std::allocator< std::vector< std::complex< float >,std::allocator< std::complex< float > > > > >":
        r"""data(tsb_vector_sink_c self) -> gr_vector_vector_complexf"""
        return _blocks_swig7.tsb_vector_sink_c_data(self)

    def tags(self) -> "std::vector< gr::tag_t,std::allocator< gr::tag_t > >":
        r"""tags(tsb_vector_sink_c self) -> tags_vector_t"""
        return _blocks_swig7.tsb_vector_sink_c_tags(self)

    @staticmethod
    def make(*args, **kwargs) -> "gr::blocks::tsb_vector_sink< std::complex< float > >::sptr":
        r"""make(unsigned int vlen=1, std::string const & tsb_key="ts_last") -> tsb_vector_sink_c_sptr"""
        return _blocks_swig7.tsb_vector_sink_c_make(*args, **kwargs)
    __swig_destroy__ = _blocks_swig7.delete_tsb_vector_sink_c

# Register tsb_vector_sink_c in _blocks_swig7:
_blocks_swig7.tsb_vector_sink_c_swigregister(tsb_vector_sink_c)

def tsb_vector_sink_c_make(*args, **kwargs) -> "gr::blocks::tsb_vector_sink< std::complex< float > >::sptr":
    r"""tsb_vector_sink_c_make(unsigned int vlen=1, std::string const & tsb_key="ts_last") -> tsb_vector_sink_c_sptr"""
    return _blocks_swig7.tsb_vector_sink_c_make(*args, **kwargs)

class tsb_vector_sink_c_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::tsb_vector_sink< gr_complex > > 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__(tsb_vector_sink_c_sptr self) -> tsb_vector_sink_c_sptr
        __init__(tsb_vector_sink_c_sptr self, tsb_vector_sink_c p) -> tsb_vector_sink_c_sptr
        """
        _blocks_swig7.tsb_vector_sink_c_sptr_swiginit(self, _blocks_swig7.new_tsb_vector_sink_c_sptr(*args))

    def __deref__(self) -> "gr::blocks::tsb_vector_sink< gr_complex > *":
        r"""__deref__(tsb_vector_sink_c_sptr self) -> tsb_vector_sink_c"""
        return _blocks_swig7.tsb_vector_sink_c_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig7.delete_tsb_vector_sink_c_sptr

    def reset(self) -> "void":
        r"""reset(tsb_vector_sink_c_sptr self)"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_reset(self)

    def data(self) -> "std::vector< std::vector< std::complex< float >,std::allocator< std::complex< float > > >,std::allocator< std::vector< std::complex< float >,std::allocator< std::complex< float > > > > >":
        r"""data(tsb_vector_sink_c_sptr self) -> gr_vector_vector_complexf"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_data(self)

    def tags(self) -> "std::vector< gr::tag_t,std::allocator< gr::tag_t > >":
        r"""tags(tsb_vector_sink_c_sptr self) -> tags_vector_t"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_tags(self)

    def make(self, *args, **kwargs) -> "gr::blocks::tsb_vector_sink< std::complex< float > >::sptr":
        r"""make(tsb_vector_sink_c_sptr self, unsigned int vlen=1, std::string const & tsb_key="ts_last") -> tsb_vector_sink_c_sptr"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_make(self, *args, **kwargs)

    def history(self) -> "unsigned int":
        r"""history(tsb_vector_sink_c_sptr self) -> unsigned int"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(tsb_vector_sink_c_sptr self, int which, int delay)
        declare_sample_delay(tsb_vector_sink_c_sptr self, unsigned int delay)
        """
        return _blocks_swig7.tsb_vector_sink_c_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(tsb_vector_sink_c_sptr self, int which) -> unsigned int"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(tsb_vector_sink_c_sptr self, int multiple)"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(tsb_vector_sink_c_sptr self) -> int"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(tsb_vector_sink_c_sptr self) -> double"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(tsb_vector_sink_c_sptr self) -> uint64_t"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(tsb_vector_sink_c_sptr self) -> uint64_t"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(tsb_vector_sink_c_sptr self) -> bool"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(tsb_vector_sink_c_sptr self) -> bool"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(tsb_vector_sink_c_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(tsb_vector_sink_c_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(tsb_vector_sink_c_sptr self, std::string level)"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(tsb_vector_sink_c_sptr self) -> std::string"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(tsb_vector_sink_c_sptr self) -> int"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(tsb_vector_sink_c_sptr self, int m)"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(tsb_vector_sink_c_sptr self)"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(tsb_vector_sink_c_sptr self) -> bool"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(tsb_vector_sink_c_sptr self, int m)"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(tsb_vector_sink_c_sptr self) -> int"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(tsb_vector_sink_c_sptr self, int i) -> long"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(tsb_vector_sink_c_sptr self, long max_output_buffer)
        set_max_output_buffer(tsb_vector_sink_c_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig7.tsb_vector_sink_c_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(tsb_vector_sink_c_sptr self, int i) -> long"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(tsb_vector_sink_c_sptr self, long min_output_buffer)
        set_min_output_buffer(tsb_vector_sink_c_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig7.tsb_vector_sink_c_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(tsb_vector_sink_c_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(tsb_vector_sink_c_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(tsb_vector_sink_c_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(tsb_vector_sink_c_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(tsb_vector_sink_c_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(tsb_vector_sink_c_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(tsb_vector_sink_c_sptr self, int which) -> float
        pc_input_buffers_full(tsb_vector_sink_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tsb_vector_sink_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(tsb_vector_sink_c_sptr self, int which) -> float
        pc_input_buffers_full_avg(tsb_vector_sink_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tsb_vector_sink_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(tsb_vector_sink_c_sptr self, int which) -> float
        pc_input_buffers_full_var(tsb_vector_sink_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tsb_vector_sink_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(tsb_vector_sink_c_sptr self, int which) -> float
        pc_output_buffers_full(tsb_vector_sink_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tsb_vector_sink_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(tsb_vector_sink_c_sptr self, int which) -> float
        pc_output_buffers_full_avg(tsb_vector_sink_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tsb_vector_sink_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(tsb_vector_sink_c_sptr self, int which) -> float
        pc_output_buffers_full_var(tsb_vector_sink_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tsb_vector_sink_c_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(tsb_vector_sink_c_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(tsb_vector_sink_c_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(tsb_vector_sink_c_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(tsb_vector_sink_c_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(tsb_vector_sink_c_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(tsb_vector_sink_c_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(tsb_vector_sink_c_sptr self)"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(tsb_vector_sink_c_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(tsb_vector_sink_c_sptr self) -> int"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(tsb_vector_sink_c_sptr self) -> int"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(tsb_vector_sink_c_sptr self, int priority) -> int"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(tsb_vector_sink_c_sptr self) -> std::string"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(tsb_vector_sink_c_sptr self) -> std::string"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(tsb_vector_sink_c_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(tsb_vector_sink_c_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(tsb_vector_sink_c_sptr self) -> long"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(tsb_vector_sink_c_sptr self) -> basic_block_sptr"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(tsb_vector_sink_c_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(tsb_vector_sink_c_sptr self) -> std::string"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(tsb_vector_sink_c_sptr self, std::string name)"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(tsb_vector_sink_c_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig7.tsb_vector_sink_c_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(tsb_vector_sink_c_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(tsb_vector_sink_c_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(tsb_vector_sink_c_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig7.tsb_vector_sink_c_sptr_message_subscribers(self, which_port)

# Register tsb_vector_sink_c_sptr in _blocks_swig7:
_blocks_swig7.tsb_vector_sink_c_sptr_swigregister(tsb_vector_sink_c_sptr)


tsb_vector_sink_c_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
tsb_vector_sink_c = tsb_vector_sink_c.make

class tsb_vector_sink_f(object):
    r"""Proxy of C++ gr::blocks::tsb_vector_sink< float > class."""

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

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

    def reset(self) -> "void":
        r"""reset(tsb_vector_sink_f self)"""
        return _blocks_swig7.tsb_vector_sink_f_reset(self)

    def data(self) -> "std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >":
        r"""data(tsb_vector_sink_f self) -> std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >"""
        return _blocks_swig7.tsb_vector_sink_f_data(self)

    def tags(self) -> "std::vector< gr::tag_t,std::allocator< gr::tag_t > >":
        r"""tags(tsb_vector_sink_f self) -> tags_vector_t"""
        return _blocks_swig7.tsb_vector_sink_f_tags(self)

    @staticmethod
    def make(*args, **kwargs) -> "gr::blocks::tsb_vector_sink< float >::sptr":
        r"""make(unsigned int vlen=1, std::string const & tsb_key="ts_last") -> tsb_vector_sink_f_sptr"""
        return _blocks_swig7.tsb_vector_sink_f_make(*args, **kwargs)
    __swig_destroy__ = _blocks_swig7.delete_tsb_vector_sink_f

# Register tsb_vector_sink_f in _blocks_swig7:
_blocks_swig7.tsb_vector_sink_f_swigregister(tsb_vector_sink_f)

def tsb_vector_sink_f_make(*args, **kwargs) -> "gr::blocks::tsb_vector_sink< float >::sptr":
    r"""tsb_vector_sink_f_make(unsigned int vlen=1, std::string const & tsb_key="ts_last") -> tsb_vector_sink_f_sptr"""
    return _blocks_swig7.tsb_vector_sink_f_make(*args, **kwargs)

class tsb_vector_sink_f_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::tsb_vector_sink< float > > 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__(tsb_vector_sink_f_sptr self) -> tsb_vector_sink_f_sptr
        __init__(tsb_vector_sink_f_sptr self, tsb_vector_sink_f p) -> tsb_vector_sink_f_sptr
        """
        _blocks_swig7.tsb_vector_sink_f_sptr_swiginit(self, _blocks_swig7.new_tsb_vector_sink_f_sptr(*args))

    def __deref__(self) -> "gr::blocks::tsb_vector_sink< float > *":
        r"""__deref__(tsb_vector_sink_f_sptr self) -> tsb_vector_sink_f"""
        return _blocks_swig7.tsb_vector_sink_f_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig7.delete_tsb_vector_sink_f_sptr

    def reset(self) -> "void":
        r"""reset(tsb_vector_sink_f_sptr self)"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_reset(self)

    def data(self) -> "std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >":
        r"""data(tsb_vector_sink_f_sptr self) -> std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_data(self)

    def tags(self) -> "std::vector< gr::tag_t,std::allocator< gr::tag_t > >":
        r"""tags(tsb_vector_sink_f_sptr self) -> tags_vector_t"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_tags(self)

    def make(self, *args, **kwargs) -> "gr::blocks::tsb_vector_sink< float >::sptr":
        r"""make(tsb_vector_sink_f_sptr self, unsigned int vlen=1, std::string const & tsb_key="ts_last") -> tsb_vector_sink_f_sptr"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_make(self, *args, **kwargs)

    def history(self) -> "unsigned int":
        r"""history(tsb_vector_sink_f_sptr self) -> unsigned int"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(tsb_vector_sink_f_sptr self, int which, int delay)
        declare_sample_delay(tsb_vector_sink_f_sptr self, unsigned int delay)
        """
        return _blocks_swig7.tsb_vector_sink_f_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(tsb_vector_sink_f_sptr self, int which) -> unsigned int"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(tsb_vector_sink_f_sptr self, int multiple)"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(tsb_vector_sink_f_sptr self) -> int"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(tsb_vector_sink_f_sptr self) -> double"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(tsb_vector_sink_f_sptr self) -> uint64_t"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(tsb_vector_sink_f_sptr self) -> uint64_t"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(tsb_vector_sink_f_sptr self) -> bool"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(tsb_vector_sink_f_sptr self) -> bool"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(tsb_vector_sink_f_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(tsb_vector_sink_f_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(tsb_vector_sink_f_sptr self, std::string level)"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(tsb_vector_sink_f_sptr self) -> std::string"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(tsb_vector_sink_f_sptr self) -> int"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(tsb_vector_sink_f_sptr self, int m)"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(tsb_vector_sink_f_sptr self)"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(tsb_vector_sink_f_sptr self) -> bool"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(tsb_vector_sink_f_sptr self, int m)"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(tsb_vector_sink_f_sptr self) -> int"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(tsb_vector_sink_f_sptr self, int i) -> long"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(tsb_vector_sink_f_sptr self, long max_output_buffer)
        set_max_output_buffer(tsb_vector_sink_f_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig7.tsb_vector_sink_f_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(tsb_vector_sink_f_sptr self, int i) -> long"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(tsb_vector_sink_f_sptr self, long min_output_buffer)
        set_min_output_buffer(tsb_vector_sink_f_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig7.tsb_vector_sink_f_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(tsb_vector_sink_f_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(tsb_vector_sink_f_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(tsb_vector_sink_f_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(tsb_vector_sink_f_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(tsb_vector_sink_f_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(tsb_vector_sink_f_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(tsb_vector_sink_f_sptr self, int which) -> float
        pc_input_buffers_full(tsb_vector_sink_f_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tsb_vector_sink_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(tsb_vector_sink_f_sptr self, int which) -> float
        pc_input_buffers_full_avg(tsb_vector_sink_f_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tsb_vector_sink_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(tsb_vector_sink_f_sptr self, int which) -> float
        pc_input_buffers_full_var(tsb_vector_sink_f_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tsb_vector_sink_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(tsb_vector_sink_f_sptr self, int which) -> float
        pc_output_buffers_full(tsb_vector_sink_f_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tsb_vector_sink_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(tsb_vector_sink_f_sptr self, int which) -> float
        pc_output_buffers_full_avg(tsb_vector_sink_f_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tsb_vector_sink_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(tsb_vector_sink_f_sptr self, int which) -> float
        pc_output_buffers_full_var(tsb_vector_sink_f_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tsb_vector_sink_f_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(tsb_vector_sink_f_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(tsb_vector_sink_f_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(tsb_vector_sink_f_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(tsb_vector_sink_f_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(tsb_vector_sink_f_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(tsb_vector_sink_f_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(tsb_vector_sink_f_sptr self)"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(tsb_vector_sink_f_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(tsb_vector_sink_f_sptr self) -> int"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(tsb_vector_sink_f_sptr self) -> int"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(tsb_vector_sink_f_sptr self, int priority) -> int"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(tsb_vector_sink_f_sptr self) -> std::string"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(tsb_vector_sink_f_sptr self) -> std::string"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(tsb_vector_sink_f_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(tsb_vector_sink_f_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(tsb_vector_sink_f_sptr self) -> long"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(tsb_vector_sink_f_sptr self) -> basic_block_sptr"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(tsb_vector_sink_f_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(tsb_vector_sink_f_sptr self) -> std::string"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(tsb_vector_sink_f_sptr self, std::string name)"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(tsb_vector_sink_f_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig7.tsb_vector_sink_f_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(tsb_vector_sink_f_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(tsb_vector_sink_f_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(tsb_vector_sink_f_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig7.tsb_vector_sink_f_sptr_message_subscribers(self, which_port)

# Register tsb_vector_sink_f_sptr in _blocks_swig7:
_blocks_swig7.tsb_vector_sink_f_sptr_swigregister(tsb_vector_sink_f_sptr)


tsb_vector_sink_f_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
tsb_vector_sink_f = tsb_vector_sink_f.make

class tsb_vector_sink_i(object):
    r"""Proxy of C++ gr::blocks::tsb_vector_sink< std::int32_t > class."""

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

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

    def reset(self) -> "void":
        r"""reset(tsb_vector_sink_i self)"""
        return _blocks_swig7.tsb_vector_sink_i_reset(self)

    def data(self) -> "std::vector< std::vector< std::int32_t,std::allocator< std::int32_t > >,std::allocator< std::vector< std::int32_t,std::allocator< std::int32_t > > > >":
        r"""data(tsb_vector_sink_i self) -> std::vector< std::vector< std::int32_t,std::allocator< std::int32_t > >,std::allocator< std::vector< std::int32_t,std::allocator< std::int32_t > > > >"""
        return _blocks_swig7.tsb_vector_sink_i_data(self)

    def tags(self) -> "std::vector< gr::tag_t,std::allocator< gr::tag_t > >":
        r"""tags(tsb_vector_sink_i self) -> tags_vector_t"""
        return _blocks_swig7.tsb_vector_sink_i_tags(self)

    @staticmethod
    def make(*args, **kwargs) -> "gr::blocks::tsb_vector_sink< int >::sptr":
        r"""make(unsigned int vlen=1, std::string const & tsb_key="ts_last") -> tsb_vector_sink_i_sptr"""
        return _blocks_swig7.tsb_vector_sink_i_make(*args, **kwargs)
    __swig_destroy__ = _blocks_swig7.delete_tsb_vector_sink_i

# Register tsb_vector_sink_i in _blocks_swig7:
_blocks_swig7.tsb_vector_sink_i_swigregister(tsb_vector_sink_i)

def tsb_vector_sink_i_make(*args, **kwargs) -> "gr::blocks::tsb_vector_sink< int >::sptr":
    r"""tsb_vector_sink_i_make(unsigned int vlen=1, std::string const & tsb_key="ts_last") -> tsb_vector_sink_i_sptr"""
    return _blocks_swig7.tsb_vector_sink_i_make(*args, **kwargs)

class tsb_vector_sink_i_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::tsb_vector_sink< std::int32_t > > class."""

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

    def __init__(self, *args):
        r"""
        __init__(tsb_vector_sink_i_sptr self) -> tsb_vector_sink_i_sptr
        __init__(tsb_vector_sink_i_sptr self, tsb_vector_sink_i p) -> tsb_vector_sink_i_sptr
        """
        _blocks_swig7.tsb_vector_sink_i_sptr_swiginit(self, _blocks_swig7.new_tsb_vector_sink_i_sptr(*args))

    def __deref__(self) -> "gr::blocks::tsb_vector_sink< std::int32_t > *":
        r"""__deref__(tsb_vector_sink_i_sptr self) -> tsb_vector_sink_i"""
        return _blocks_swig7.tsb_vector_sink_i_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig7.delete_tsb_vector_sink_i_sptr

    def reset(self) -> "void":
        r"""reset(tsb_vector_sink_i_sptr self)"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_reset(self)

    def data(self) -> "std::vector< std::vector< std::int32_t,std::allocator< std::int32_t > >,std::allocator< std::vector< std::int32_t,std::allocator< std::int32_t > > > >":
        r"""data(tsb_vector_sink_i_sptr self) -> std::vector< std::vector< std::int32_t,std::allocator< std::int32_t > >,std::allocator< std::vector< std::int32_t,std::allocator< std::int32_t > > > >"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_data(self)

    def tags(self) -> "std::vector< gr::tag_t,std::allocator< gr::tag_t > >":
        r"""tags(tsb_vector_sink_i_sptr self) -> tags_vector_t"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_tags(self)

    def make(self, *args, **kwargs) -> "gr::blocks::tsb_vector_sink< int >::sptr":
        r"""make(tsb_vector_sink_i_sptr self, unsigned int vlen=1, std::string const & tsb_key="ts_last") -> tsb_vector_sink_i_sptr"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_make(self, *args, **kwargs)

    def history(self) -> "unsigned int":
        r"""history(tsb_vector_sink_i_sptr self) -> unsigned int"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(tsb_vector_sink_i_sptr self, int which, int delay)
        declare_sample_delay(tsb_vector_sink_i_sptr self, unsigned int delay)
        """
        return _blocks_swig7.tsb_vector_sink_i_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(tsb_vector_sink_i_sptr self, int which) -> unsigned int"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(tsb_vector_sink_i_sptr self, int multiple)"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(tsb_vector_sink_i_sptr self) -> int"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(tsb_vector_sink_i_sptr self) -> double"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(tsb_vector_sink_i_sptr self) -> uint64_t"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(tsb_vector_sink_i_sptr self) -> uint64_t"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(tsb_vector_sink_i_sptr self) -> bool"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(tsb_vector_sink_i_sptr self) -> bool"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(tsb_vector_sink_i_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(tsb_vector_sink_i_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(tsb_vector_sink_i_sptr self, std::string level)"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(tsb_vector_sink_i_sptr self) -> std::string"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(tsb_vector_sink_i_sptr self) -> int"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(tsb_vector_sink_i_sptr self, int m)"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(tsb_vector_sink_i_sptr self)"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(tsb_vector_sink_i_sptr self) -> bool"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(tsb_vector_sink_i_sptr self, int m)"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(tsb_vector_sink_i_sptr self) -> int"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(tsb_vector_sink_i_sptr self, int i) -> long"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(tsb_vector_sink_i_sptr self, long max_output_buffer)
        set_max_output_buffer(tsb_vector_sink_i_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig7.tsb_vector_sink_i_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(tsb_vector_sink_i_sptr self, int i) -> long"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(tsb_vector_sink_i_sptr self, long min_output_buffer)
        set_min_output_buffer(tsb_vector_sink_i_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig7.tsb_vector_sink_i_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(tsb_vector_sink_i_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(tsb_vector_sink_i_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(tsb_vector_sink_i_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(tsb_vector_sink_i_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(tsb_vector_sink_i_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(tsb_vector_sink_i_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(tsb_vector_sink_i_sptr self, int which) -> float
        pc_input_buffers_full(tsb_vector_sink_i_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tsb_vector_sink_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(tsb_vector_sink_i_sptr self, int which) -> float
        pc_input_buffers_full_avg(tsb_vector_sink_i_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tsb_vector_sink_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(tsb_vector_sink_i_sptr self, int which) -> float
        pc_input_buffers_full_var(tsb_vector_sink_i_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tsb_vector_sink_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(tsb_vector_sink_i_sptr self, int which) -> float
        pc_output_buffers_full(tsb_vector_sink_i_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tsb_vector_sink_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(tsb_vector_sink_i_sptr self, int which) -> float
        pc_output_buffers_full_avg(tsb_vector_sink_i_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tsb_vector_sink_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(tsb_vector_sink_i_sptr self, int which) -> float
        pc_output_buffers_full_var(tsb_vector_sink_i_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tsb_vector_sink_i_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(tsb_vector_sink_i_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(tsb_vector_sink_i_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(tsb_vector_sink_i_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(tsb_vector_sink_i_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(tsb_vector_sink_i_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(tsb_vector_sink_i_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(tsb_vector_sink_i_sptr self)"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(tsb_vector_sink_i_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(tsb_vector_sink_i_sptr self) -> int"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(tsb_vector_sink_i_sptr self) -> int"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(tsb_vector_sink_i_sptr self, int priority) -> int"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(tsb_vector_sink_i_sptr self) -> std::string"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(tsb_vector_sink_i_sptr self) -> std::string"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(tsb_vector_sink_i_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(tsb_vector_sink_i_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(tsb_vector_sink_i_sptr self) -> long"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(tsb_vector_sink_i_sptr self) -> basic_block_sptr"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(tsb_vector_sink_i_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(tsb_vector_sink_i_sptr self) -> std::string"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(tsb_vector_sink_i_sptr self, std::string name)"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(tsb_vector_sink_i_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig7.tsb_vector_sink_i_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(tsb_vector_sink_i_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(tsb_vector_sink_i_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(tsb_vector_sink_i_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig7.tsb_vector_sink_i_sptr_message_subscribers(self, which_port)

# Register tsb_vector_sink_i_sptr in _blocks_swig7:
_blocks_swig7.tsb_vector_sink_i_sptr_swigregister(tsb_vector_sink_i_sptr)


tsb_vector_sink_i_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
tsb_vector_sink_i = tsb_vector_sink_i.make

class tsb_vector_sink_s(object):
    r"""Proxy of C++ gr::blocks::tsb_vector_sink< std::int16_t > class."""

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

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

    def reset(self) -> "void":
        r"""reset(tsb_vector_sink_s self)"""
        return _blocks_swig7.tsb_vector_sink_s_reset(self)

    def data(self) -> "std::vector< std::vector< std::int16_t,std::allocator< std::int16_t > >,std::allocator< std::vector< std::int16_t,std::allocator< std::int16_t > > > >":
        r"""data(tsb_vector_sink_s self) -> std::vector< std::vector< std::int16_t,std::allocator< std::int16_t > >,std::allocator< std::vector< std::int16_t,std::allocator< std::int16_t > > > >"""
        return _blocks_swig7.tsb_vector_sink_s_data(self)

    def tags(self) -> "std::vector< gr::tag_t,std::allocator< gr::tag_t > >":
        r"""tags(tsb_vector_sink_s self) -> tags_vector_t"""
        return _blocks_swig7.tsb_vector_sink_s_tags(self)

    @staticmethod
    def make(*args, **kwargs) -> "gr::blocks::tsb_vector_sink< short >::sptr":
        r"""make(unsigned int vlen=1, std::string const & tsb_key="ts_last") -> tsb_vector_sink_s_sptr"""
        return _blocks_swig7.tsb_vector_sink_s_make(*args, **kwargs)
    __swig_destroy__ = _blocks_swig7.delete_tsb_vector_sink_s

# Register tsb_vector_sink_s in _blocks_swig7:
_blocks_swig7.tsb_vector_sink_s_swigregister(tsb_vector_sink_s)

def tsb_vector_sink_s_make(*args, **kwargs) -> "gr::blocks::tsb_vector_sink< short >::sptr":
    r"""tsb_vector_sink_s_make(unsigned int vlen=1, std::string const & tsb_key="ts_last") -> tsb_vector_sink_s_sptr"""
    return _blocks_swig7.tsb_vector_sink_s_make(*args, **kwargs)

class tsb_vector_sink_s_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::tsb_vector_sink< std::int16_t > > class."""

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

    def __init__(self, *args):
        r"""
        __init__(tsb_vector_sink_s_sptr self) -> tsb_vector_sink_s_sptr
        __init__(tsb_vector_sink_s_sptr self, tsb_vector_sink_s p) -> tsb_vector_sink_s_sptr
        """
        _blocks_swig7.tsb_vector_sink_s_sptr_swiginit(self, _blocks_swig7.new_tsb_vector_sink_s_sptr(*args))

    def __deref__(self) -> "gr::blocks::tsb_vector_sink< std::int16_t > *":
        r"""__deref__(tsb_vector_sink_s_sptr self) -> tsb_vector_sink_s"""
        return _blocks_swig7.tsb_vector_sink_s_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig7.delete_tsb_vector_sink_s_sptr

    def reset(self) -> "void":
        r"""reset(tsb_vector_sink_s_sptr self)"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_reset(self)

    def data(self) -> "std::vector< std::vector< std::int16_t,std::allocator< std::int16_t > >,std::allocator< std::vector< std::int16_t,std::allocator< std::int16_t > > > >":
        r"""data(tsb_vector_sink_s_sptr self) -> std::vector< std::vector< std::int16_t,std::allocator< std::int16_t > >,std::allocator< std::vector< std::int16_t,std::allocator< std::int16_t > > > >"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_data(self)

    def tags(self) -> "std::vector< gr::tag_t,std::allocator< gr::tag_t > >":
        r"""tags(tsb_vector_sink_s_sptr self) -> tags_vector_t"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_tags(self)

    def make(self, *args, **kwargs) -> "gr::blocks::tsb_vector_sink< short >::sptr":
        r"""make(tsb_vector_sink_s_sptr self, unsigned int vlen=1, std::string const & tsb_key="ts_last") -> tsb_vector_sink_s_sptr"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_make(self, *args, **kwargs)

    def history(self) -> "unsigned int":
        r"""history(tsb_vector_sink_s_sptr self) -> unsigned int"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(tsb_vector_sink_s_sptr self, int which, int delay)
        declare_sample_delay(tsb_vector_sink_s_sptr self, unsigned int delay)
        """
        return _blocks_swig7.tsb_vector_sink_s_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(tsb_vector_sink_s_sptr self, int which) -> unsigned int"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(tsb_vector_sink_s_sptr self, int multiple)"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(tsb_vector_sink_s_sptr self) -> int"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(tsb_vector_sink_s_sptr self) -> double"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(tsb_vector_sink_s_sptr self) -> uint64_t"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(tsb_vector_sink_s_sptr self) -> uint64_t"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(tsb_vector_sink_s_sptr self) -> bool"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(tsb_vector_sink_s_sptr self) -> bool"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(tsb_vector_sink_s_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(tsb_vector_sink_s_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(tsb_vector_sink_s_sptr self, std::string level)"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(tsb_vector_sink_s_sptr self) -> std::string"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(tsb_vector_sink_s_sptr self) -> int"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(tsb_vector_sink_s_sptr self, int m)"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(tsb_vector_sink_s_sptr self)"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(tsb_vector_sink_s_sptr self) -> bool"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(tsb_vector_sink_s_sptr self, int m)"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(tsb_vector_sink_s_sptr self) -> int"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(tsb_vector_sink_s_sptr self, int i) -> long"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(tsb_vector_sink_s_sptr self, long max_output_buffer)
        set_max_output_buffer(tsb_vector_sink_s_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig7.tsb_vector_sink_s_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(tsb_vector_sink_s_sptr self, int i) -> long"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(tsb_vector_sink_s_sptr self, long min_output_buffer)
        set_min_output_buffer(tsb_vector_sink_s_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig7.tsb_vector_sink_s_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(tsb_vector_sink_s_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(tsb_vector_sink_s_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(tsb_vector_sink_s_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(tsb_vector_sink_s_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(tsb_vector_sink_s_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(tsb_vector_sink_s_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(tsb_vector_sink_s_sptr self, int which) -> float
        pc_input_buffers_full(tsb_vector_sink_s_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tsb_vector_sink_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(tsb_vector_sink_s_sptr self, int which) -> float
        pc_input_buffers_full_avg(tsb_vector_sink_s_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tsb_vector_sink_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(tsb_vector_sink_s_sptr self, int which) -> float
        pc_input_buffers_full_var(tsb_vector_sink_s_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tsb_vector_sink_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(tsb_vector_sink_s_sptr self, int which) -> float
        pc_output_buffers_full(tsb_vector_sink_s_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tsb_vector_sink_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(tsb_vector_sink_s_sptr self, int which) -> float
        pc_output_buffers_full_avg(tsb_vector_sink_s_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tsb_vector_sink_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(tsb_vector_sink_s_sptr self, int which) -> float
        pc_output_buffers_full_var(tsb_vector_sink_s_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.tsb_vector_sink_s_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(tsb_vector_sink_s_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(tsb_vector_sink_s_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(tsb_vector_sink_s_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(tsb_vector_sink_s_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(tsb_vector_sink_s_sptr self) -> float"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(tsb_vector_sink_s_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(tsb_vector_sink_s_sptr self)"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(tsb_vector_sink_s_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(tsb_vector_sink_s_sptr self) -> int"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(tsb_vector_sink_s_sptr self) -> int"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(tsb_vector_sink_s_sptr self, int priority) -> int"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(tsb_vector_sink_s_sptr self) -> std::string"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(tsb_vector_sink_s_sptr self) -> std::string"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(tsb_vector_sink_s_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(tsb_vector_sink_s_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(tsb_vector_sink_s_sptr self) -> long"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(tsb_vector_sink_s_sptr self) -> basic_block_sptr"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(tsb_vector_sink_s_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(tsb_vector_sink_s_sptr self) -> std::string"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(tsb_vector_sink_s_sptr self, std::string name)"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(tsb_vector_sink_s_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig7.tsb_vector_sink_s_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(tsb_vector_sink_s_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(tsb_vector_sink_s_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(tsb_vector_sink_s_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig7.tsb_vector_sink_s_sptr_message_subscribers(self, which_port)

# Register tsb_vector_sink_s_sptr in _blocks_swig7:
_blocks_swig7.tsb_vector_sink_s_sptr_swigregister(tsb_vector_sink_s_sptr)


tsb_vector_sink_s_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
tsb_vector_sink_s = tsb_vector_sink_s.make

class throttle_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::throttle > 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__(throttle_sptr self) -> throttle_sptr
        __init__(throttle_sptr self, throttle p) -> throttle_sptr
        """
        _blocks_swig7.throttle_sptr_swiginit(self, _blocks_swig7.new_throttle_sptr(*args))

    def __deref__(self) -> "gr::blocks::throttle *":
        r"""__deref__(throttle_sptr self) -> throttle"""
        return _blocks_swig7.throttle_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig7.delete_throttle_sptr

    def make(self, itemsize: "size_t", samples_per_sec: "double", ignore_tags: "bool"=True) -> "gr::blocks::throttle::sptr":
        r"""make(throttle_sptr self, size_t itemsize, double samples_per_sec, bool ignore_tags=True) -> throttle_sptr"""
        return _blocks_swig7.throttle_sptr_make(self, itemsize, samples_per_sec, ignore_tags)

    def set_sample_rate(self, rate: "double") -> "void":
        r"""set_sample_rate(throttle_sptr self, double rate)"""
        return _blocks_swig7.throttle_sptr_set_sample_rate(self, rate)

    def sample_rate(self) -> "double":
        r"""sample_rate(throttle_sptr self) -> double"""
        return _blocks_swig7.throttle_sptr_sample_rate(self)

    def history(self) -> "unsigned int":
        r"""history(throttle_sptr self) -> unsigned int"""
        return _blocks_swig7.throttle_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(throttle_sptr self, int which, int delay)
        declare_sample_delay(throttle_sptr self, unsigned int delay)
        """
        return _blocks_swig7.throttle_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(throttle_sptr self, int which) -> unsigned int"""
        return _blocks_swig7.throttle_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(throttle_sptr self, int multiple)"""
        return _blocks_swig7.throttle_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(throttle_sptr self) -> int"""
        return _blocks_swig7.throttle_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(throttle_sptr self) -> double"""
        return _blocks_swig7.throttle_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(throttle_sptr self) -> uint64_t"""
        return _blocks_swig7.throttle_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(throttle_sptr self) -> uint64_t"""
        return _blocks_swig7.throttle_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(throttle_sptr self) -> bool"""
        return _blocks_swig7.throttle_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(throttle_sptr self) -> bool"""
        return _blocks_swig7.throttle_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(throttle_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig7.throttle_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(throttle_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig7.throttle_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(throttle_sptr self, std::string level)"""
        return _blocks_swig7.throttle_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(throttle_sptr self) -> std::string"""
        return _blocks_swig7.throttle_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(throttle_sptr self) -> int"""
        return _blocks_swig7.throttle_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(throttle_sptr self, int m)"""
        return _blocks_swig7.throttle_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(throttle_sptr self)"""
        return _blocks_swig7.throttle_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(throttle_sptr self) -> bool"""
        return _blocks_swig7.throttle_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(throttle_sptr self, int m)"""
        return _blocks_swig7.throttle_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(throttle_sptr self) -> int"""
        return _blocks_swig7.throttle_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(throttle_sptr self, int i) -> long"""
        return _blocks_swig7.throttle_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(throttle_sptr self, long max_output_buffer)
        set_max_output_buffer(throttle_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig7.throttle_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(throttle_sptr self, int i) -> long"""
        return _blocks_swig7.throttle_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(throttle_sptr self, long min_output_buffer)
        set_min_output_buffer(throttle_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig7.throttle_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(throttle_sptr self) -> float"""
        return _blocks_swig7.throttle_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(throttle_sptr self) -> float"""
        return _blocks_swig7.throttle_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(throttle_sptr self) -> float"""
        return _blocks_swig7.throttle_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(throttle_sptr self) -> float"""
        return _blocks_swig7.throttle_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(throttle_sptr self) -> float"""
        return _blocks_swig7.throttle_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(throttle_sptr self) -> float"""
        return _blocks_swig7.throttle_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(throttle_sptr self, int which) -> float
        pc_input_buffers_full(throttle_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.throttle_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(throttle_sptr self, int which) -> float
        pc_input_buffers_full_avg(throttle_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.throttle_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(throttle_sptr self, int which) -> float
        pc_input_buffers_full_var(throttle_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.throttle_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(throttle_sptr self, int which) -> float
        pc_output_buffers_full(throttle_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.throttle_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(throttle_sptr self, int which) -> float
        pc_output_buffers_full_avg(throttle_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.throttle_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(throttle_sptr self, int which) -> float
        pc_output_buffers_full_var(throttle_sptr self) -> pmt_vector_float
        """
        return _blocks_swig7.throttle_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(throttle_sptr self) -> float"""
        return _blocks_swig7.throttle_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(throttle_sptr self) -> float"""
        return _blocks_swig7.throttle_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(throttle_sptr self) -> float"""
        return _blocks_swig7.throttle_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(throttle_sptr self) -> float"""
        return _blocks_swig7.throttle_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(throttle_sptr self) -> float"""
        return _blocks_swig7.throttle_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(throttle_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig7.throttle_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(throttle_sptr self)"""
        return _blocks_swig7.throttle_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(throttle_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig7.throttle_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(throttle_sptr self) -> int"""
        return _blocks_swig7.throttle_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(throttle_sptr self) -> int"""
        return _blocks_swig7.throttle_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(throttle_sptr self, int priority) -> int"""
        return _blocks_swig7.throttle_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(throttle_sptr self) -> std::string"""
        return _blocks_swig7.throttle_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(throttle_sptr self) -> std::string"""
        return _blocks_swig7.throttle_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(throttle_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.throttle_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(throttle_sptr self) -> io_signature_sptr"""
        return _blocks_swig7.throttle_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(throttle_sptr self) -> long"""
        return _blocks_swig7.throttle_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(throttle_sptr self) -> basic_block_sptr"""
        return _blocks_swig7.throttle_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(throttle_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig7.throttle_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(throttle_sptr self) -> std::string"""
        return _blocks_swig7.throttle_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(throttle_sptr self, std::string name)"""
        return _blocks_swig7.throttle_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(throttle_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig7.throttle_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(throttle_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig7.throttle_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(throttle_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig7.throttle_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(throttle_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig7.throttle_sptr_message_subscribers(self, which_port)

# Register throttle_sptr in _blocks_swig7:
_blocks_swig7.throttle_sptr_swigregister(throttle_sptr)


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



