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

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

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

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_swig4.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_swig4.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_swig4.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_swig4.high_res_timer_epoch()
byte_t = _blocks_swig4.byte_t

float_t = _blocks_swig4.float_t

complex_t = _blocks_swig4.complex_t


def pdu_port_id() -> "pmt::pmt_t const":
    r"""pdu_port_id() -> swig_pmt_ptr"""
    return _blocks_swig4.pdu_port_id()

def itemsize(type: "gr::blocks::pdu::vector_type") -> "size_t":
    r"""itemsize(gr::blocks::pdu::vector_type type) -> size_t"""
    return _blocks_swig4.itemsize(type)

def type_matches(type: "gr::blocks::pdu::vector_type", v: "swig_pmt_ptr") -> "bool":
    r"""type_matches(gr::blocks::pdu::vector_type type, swig_pmt_ptr v) -> bool"""
    return _blocks_swig4.type_matches(type, v)

def make_pdu_vector(type: "gr::blocks::pdu::vector_type", buf: "uint8_t const *", items: "size_t") -> "pmt::pmt_t":
    r"""make_pdu_vector(gr::blocks::pdu::vector_type type, uint8_t const * buf, size_t items) -> swig_pmt_ptr"""
    return _blocks_swig4.make_pdu_vector(type, buf, items)

def type_from_pmt(vector: "swig_pmt_ptr") -> "gr::blocks::pdu::vector_type":
    r"""type_from_pmt(swig_pmt_ptr vector) -> gr::blocks::pdu::vector_type"""
    return _blocks_swig4.type_from_pmt(vector)
class pdu_filter(object):
    r"""Proxy of C++ gr::blocks::pdu_filter 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(k: "swig_pmt_ptr", v: "swig_pmt_ptr", invert: "bool"=False) -> "gr::blocks::pdu_filter::sptr":
        r"""make(swig_pmt_ptr k, swig_pmt_ptr v, bool invert=False) -> pdu_filter_sptr"""
        return _blocks_swig4.pdu_filter_make(k, v, invert)

    def set_key(self, key: "swig_pmt_ptr") -> "void":
        r"""set_key(pdu_filter self, swig_pmt_ptr key)"""
        return _blocks_swig4.pdu_filter_set_key(self, key)

    def set_val(self, val: "swig_pmt_ptr") -> "void":
        r"""set_val(pdu_filter self, swig_pmt_ptr val)"""
        return _blocks_swig4.pdu_filter_set_val(self, val)

    def set_inversion(self, invert: "bool") -> "void":
        r"""set_inversion(pdu_filter self, bool invert)"""
        return _blocks_swig4.pdu_filter_set_inversion(self, invert)
    __swig_destroy__ = _blocks_swig4.delete_pdu_filter

# Register pdu_filter in _blocks_swig4:
_blocks_swig4.pdu_filter_swigregister(pdu_filter)

def pdu_filter_make(k: "swig_pmt_ptr", v: "swig_pmt_ptr", invert: "bool"=False) -> "gr::blocks::pdu_filter::sptr":
    r"""pdu_filter_make(swig_pmt_ptr k, swig_pmt_ptr v, bool invert=False) -> pdu_filter_sptr"""
    return _blocks_swig4.pdu_filter_make(k, v, invert)

class pdu_set(object):
    r"""Proxy of C++ gr::blocks::pdu_set 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(k: "swig_pmt_ptr", v: "swig_pmt_ptr") -> "gr::blocks::pdu_set::sptr":
        r"""make(swig_pmt_ptr k, swig_pmt_ptr v) -> pdu_set_sptr"""
        return _blocks_swig4.pdu_set_make(k, v)

    def set_key(self, key: "swig_pmt_ptr") -> "void":
        r"""set_key(pdu_set self, swig_pmt_ptr key)"""
        return _blocks_swig4.pdu_set_set_key(self, key)

    def set_val(self, val: "swig_pmt_ptr") -> "void":
        r"""set_val(pdu_set self, swig_pmt_ptr val)"""
        return _blocks_swig4.pdu_set_set_val(self, val)
    __swig_destroy__ = _blocks_swig4.delete_pdu_set

# Register pdu_set in _blocks_swig4:
_blocks_swig4.pdu_set_swigregister(pdu_set)

def pdu_set_make(k: "swig_pmt_ptr", v: "swig_pmt_ptr") -> "gr::blocks::pdu_set::sptr":
    r"""pdu_set_make(swig_pmt_ptr k, swig_pmt_ptr v) -> pdu_set_sptr"""
    return _blocks_swig4.pdu_set_make(k, v)

class pdu_remove(object):
    r"""Proxy of C++ gr::blocks::pdu_remove 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(k: "swig_pmt_ptr") -> "gr::blocks::pdu_remove::sptr":
        r"""make(swig_pmt_ptr k) -> pdu_remove_sptr"""
        return _blocks_swig4.pdu_remove_make(k)

    def set_key(self, key: "swig_pmt_ptr") -> "void":
        r"""set_key(pdu_remove self, swig_pmt_ptr key)"""
        return _blocks_swig4.pdu_remove_set_key(self, key)
    __swig_destroy__ = _blocks_swig4.delete_pdu_remove

# Register pdu_remove in _blocks_swig4:
_blocks_swig4.pdu_remove_swigregister(pdu_remove)

def pdu_remove_make(k: "swig_pmt_ptr") -> "gr::blocks::pdu_remove::sptr":
    r"""pdu_remove_make(swig_pmt_ptr k) -> pdu_remove_sptr"""
    return _blocks_swig4.pdu_remove_make(k)

class pdu_to_tagged_stream(object):
    r"""Proxy of C++ gr::blocks::pdu_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")
    __repr__ = _swig_repr

    @staticmethod
    def make(*args, **kwargs) -> "gr::blocks::pdu_to_tagged_stream::sptr":
        r"""make(gr::blocks::pdu::vector_type type, std::string const & lengthtagname="packet_len") -> pdu_to_tagged_stream_sptr"""
        return _blocks_swig4.pdu_to_tagged_stream_make(*args, **kwargs)
    __swig_destroy__ = _blocks_swig4.delete_pdu_to_tagged_stream

# Register pdu_to_tagged_stream in _blocks_swig4:
_blocks_swig4.pdu_to_tagged_stream_swigregister(pdu_to_tagged_stream)

def pdu_to_tagged_stream_make(*args, **kwargs) -> "gr::blocks::pdu_to_tagged_stream::sptr":
    r"""pdu_to_tagged_stream_make(gr::blocks::pdu::vector_type type, std::string const & lengthtagname="packet_len") -> pdu_to_tagged_stream_sptr"""
    return _blocks_swig4.pdu_to_tagged_stream_make(*args, **kwargs)

class peak_detector2_fb(object):
    r"""Proxy of C++ gr::blocks::peak_detector2_fb 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(threshold_factor_rise: "float"=7, look_ahead: "int"=1000, alpha: "float"=0.001) -> "gr::blocks::peak_detector2_fb::sptr":
        r"""make(float threshold_factor_rise=7, int look_ahead=1000, float alpha=0.001) -> peak_detector2_fb_sptr"""
        return _blocks_swig4.peak_detector2_fb_make(threshold_factor_rise, look_ahead, alpha)

    def set_threshold_factor_rise(self, thr: "float") -> "void":
        r"""set_threshold_factor_rise(peak_detector2_fb self, float thr)"""
        return _blocks_swig4.peak_detector2_fb_set_threshold_factor_rise(self, thr)

    def set_look_ahead(self, look: "int") -> "void":
        r"""set_look_ahead(peak_detector2_fb self, int look)"""
        return _blocks_swig4.peak_detector2_fb_set_look_ahead(self, look)

    def set_alpha(self, alpha: "float") -> "void":
        r"""set_alpha(peak_detector2_fb self, float alpha)"""
        return _blocks_swig4.peak_detector2_fb_set_alpha(self, alpha)

    def threshold_factor_rise(self) -> "float":
        r"""threshold_factor_rise(peak_detector2_fb self) -> float"""
        return _blocks_swig4.peak_detector2_fb_threshold_factor_rise(self)

    def look_ahead(self) -> "int":
        r"""look_ahead(peak_detector2_fb self) -> int"""
        return _blocks_swig4.peak_detector2_fb_look_ahead(self)

    def alpha(self) -> "float":
        r"""alpha(peak_detector2_fb self) -> float"""
        return _blocks_swig4.peak_detector2_fb_alpha(self)
    __swig_destroy__ = _blocks_swig4.delete_peak_detector2_fb

# Register peak_detector2_fb in _blocks_swig4:
_blocks_swig4.peak_detector2_fb_swigregister(peak_detector2_fb)

def peak_detector2_fb_make(threshold_factor_rise: "float"=7, look_ahead: "int"=1000, alpha: "float"=0.001) -> "gr::blocks::peak_detector2_fb::sptr":
    r"""peak_detector2_fb_make(float threshold_factor_rise=7, int look_ahead=1000, float alpha=0.001) -> peak_detector2_fb_sptr"""
    return _blocks_swig4.peak_detector2_fb_make(threshold_factor_rise, look_ahead, alpha)

class plateau_detector_fb(object):
    r"""Proxy of C++ gr::blocks::plateau_detector_fb 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(max_len: "int", threshold: "float"=0.9) -> "gr::blocks::plateau_detector_fb::sptr":
        r"""make(int max_len, float threshold=0.9) -> plateau_detector_fb_sptr"""
        return _blocks_swig4.plateau_detector_fb_make(max_len, threshold)

    def set_threshold(self, threshold: "float") -> "void":
        r"""set_threshold(plateau_detector_fb self, float threshold)"""
        return _blocks_swig4.plateau_detector_fb_set_threshold(self, threshold)

    def threshold(self) -> "float":
        r"""threshold(plateau_detector_fb self) -> float"""
        return _blocks_swig4.plateau_detector_fb_threshold(self)
    __swig_destroy__ = _blocks_swig4.delete_plateau_detector_fb

# Register plateau_detector_fb in _blocks_swig4:
_blocks_swig4.plateau_detector_fb_swigregister(plateau_detector_fb)

def plateau_detector_fb_make(max_len: "int", threshold: "float"=0.9) -> "gr::blocks::plateau_detector_fb::sptr":
    r"""plateau_detector_fb_make(int max_len, float threshold=0.9) -> plateau_detector_fb_sptr"""
    return _blocks_swig4.plateau_detector_fb_make(max_len, threshold)

class probe_rate(object):
    r"""Proxy of C++ gr::blocks::probe_rate 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", update_rate_ms: "double"=500.0, alpha: "double"=0.0001) -> "gr::blocks::probe_rate::sptr":
        r"""make(size_t itemsize, double update_rate_ms=500.0, double alpha=0.0001) -> probe_rate_sptr"""
        return _blocks_swig4.probe_rate_make(itemsize, update_rate_ms, alpha)

    def set_alpha(self, alpha: "double") -> "void":
        r"""set_alpha(probe_rate self, double alpha)"""
        return _blocks_swig4.probe_rate_set_alpha(self, alpha)

    def rate(self) -> "double":
        r"""rate(probe_rate self) -> double"""
        return _blocks_swig4.probe_rate_rate(self)

    def start(self) -> "bool":
        r"""start(probe_rate self) -> bool"""
        return _blocks_swig4.probe_rate_start(self)

    def stop(self) -> "bool":
        r"""stop(probe_rate self) -> bool"""
        return _blocks_swig4.probe_rate_stop(self)
    __swig_destroy__ = _blocks_swig4.delete_probe_rate

# Register probe_rate in _blocks_swig4:
_blocks_swig4.probe_rate_swigregister(probe_rate)

def probe_rate_make(itemsize: "size_t", update_rate_ms: "double"=500.0, alpha: "double"=0.0001) -> "gr::blocks::probe_rate::sptr":
    r"""probe_rate_make(size_t itemsize, double update_rate_ms=500.0, double alpha=0.0001) -> probe_rate_sptr"""
    return _blocks_swig4.probe_rate_make(itemsize, update_rate_ms, alpha)

class peak_detector_fb(object):
    r"""Proxy of C++ gr::blocks::peak_detector< 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

    @staticmethod
    def make(threshold_factor_rise: "float"=0.25, threshold_factor_fall: "float"=0.40, look_ahead: "int"=10, alpha: "float"=0.001) -> "gr::blocks::peak_detector< float >::sptr":
        r"""make(float threshold_factor_rise=0.25, float threshold_factor_fall=0.40, int look_ahead=10, float alpha=0.001) -> peak_detector_fb_sptr"""
        return _blocks_swig4.peak_detector_fb_make(threshold_factor_rise, threshold_factor_fall, look_ahead, alpha)

    def set_threshold_factor_rise(self, thr: "float") -> "void":
        r"""set_threshold_factor_rise(peak_detector_fb self, float thr)"""
        return _blocks_swig4.peak_detector_fb_set_threshold_factor_rise(self, thr)

    def set_threshold_factor_fall(self, thr: "float") -> "void":
        r"""set_threshold_factor_fall(peak_detector_fb self, float thr)"""
        return _blocks_swig4.peak_detector_fb_set_threshold_factor_fall(self, thr)

    def set_look_ahead(self, look: "int") -> "void":
        r"""set_look_ahead(peak_detector_fb self, int look)"""
        return _blocks_swig4.peak_detector_fb_set_look_ahead(self, look)

    def set_alpha(self, alpha: "float") -> "void":
        r"""set_alpha(peak_detector_fb self, float alpha)"""
        return _blocks_swig4.peak_detector_fb_set_alpha(self, alpha)

    def threshold_factor_rise(self) -> "float":
        r"""threshold_factor_rise(peak_detector_fb self) -> float"""
        return _blocks_swig4.peak_detector_fb_threshold_factor_rise(self)

    def threshold_factor_fall(self) -> "float":
        r"""threshold_factor_fall(peak_detector_fb self) -> float"""
        return _blocks_swig4.peak_detector_fb_threshold_factor_fall(self)

    def look_ahead(self) -> "int":
        r"""look_ahead(peak_detector_fb self) -> int"""
        return _blocks_swig4.peak_detector_fb_look_ahead(self)

    def alpha(self) -> "float":
        r"""alpha(peak_detector_fb self) -> float"""
        return _blocks_swig4.peak_detector_fb_alpha(self)
    __swig_destroy__ = _blocks_swig4.delete_peak_detector_fb

# Register peak_detector_fb in _blocks_swig4:
_blocks_swig4.peak_detector_fb_swigregister(peak_detector_fb)

def peak_detector_fb_make(threshold_factor_rise: "float"=0.25, threshold_factor_fall: "float"=0.40, look_ahead: "int"=10, alpha: "float"=0.001) -> "gr::blocks::peak_detector< float >::sptr":
    r"""peak_detector_fb_make(float threshold_factor_rise=0.25, float threshold_factor_fall=0.40, int look_ahead=10, float alpha=0.001) -> peak_detector_fb_sptr"""
    return _blocks_swig4.peak_detector_fb_make(threshold_factor_rise, threshold_factor_fall, look_ahead, alpha)

class peak_detector_fb_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::peak_detector< 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__(peak_detector_fb_sptr self) -> peak_detector_fb_sptr
        __init__(peak_detector_fb_sptr self, peak_detector_fb p) -> peak_detector_fb_sptr
        """
        _blocks_swig4.peak_detector_fb_sptr_swiginit(self, _blocks_swig4.new_peak_detector_fb_sptr(*args))

    def __deref__(self) -> "gr::blocks::peak_detector< float > *":
        r"""__deref__(peak_detector_fb_sptr self) -> peak_detector_fb"""
        return _blocks_swig4.peak_detector_fb_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig4.delete_peak_detector_fb_sptr

    def make(self, threshold_factor_rise: "float"=0.25, threshold_factor_fall: "float"=0.40, look_ahead: "int"=10, alpha: "float"=0.001) -> "gr::blocks::peak_detector< float >::sptr":
        r"""make(peak_detector_fb_sptr self, float threshold_factor_rise=0.25, float threshold_factor_fall=0.40, int look_ahead=10, float alpha=0.001) -> peak_detector_fb_sptr"""
        return _blocks_swig4.peak_detector_fb_sptr_make(self, threshold_factor_rise, threshold_factor_fall, look_ahead, alpha)

    def set_threshold_factor_rise(self, thr: "float") -> "void":
        r"""set_threshold_factor_rise(peak_detector_fb_sptr self, float thr)"""
        return _blocks_swig4.peak_detector_fb_sptr_set_threshold_factor_rise(self, thr)

    def set_threshold_factor_fall(self, thr: "float") -> "void":
        r"""set_threshold_factor_fall(peak_detector_fb_sptr self, float thr)"""
        return _blocks_swig4.peak_detector_fb_sptr_set_threshold_factor_fall(self, thr)

    def set_look_ahead(self, look: "int") -> "void":
        r"""set_look_ahead(peak_detector_fb_sptr self, int look)"""
        return _blocks_swig4.peak_detector_fb_sptr_set_look_ahead(self, look)

    def set_alpha(self, alpha: "float") -> "void":
        r"""set_alpha(peak_detector_fb_sptr self, float alpha)"""
        return _blocks_swig4.peak_detector_fb_sptr_set_alpha(self, alpha)

    def threshold_factor_rise(self) -> "float":
        r"""threshold_factor_rise(peak_detector_fb_sptr self) -> float"""
        return _blocks_swig4.peak_detector_fb_sptr_threshold_factor_rise(self)

    def threshold_factor_fall(self) -> "float":
        r"""threshold_factor_fall(peak_detector_fb_sptr self) -> float"""
        return _blocks_swig4.peak_detector_fb_sptr_threshold_factor_fall(self)

    def look_ahead(self) -> "int":
        r"""look_ahead(peak_detector_fb_sptr self) -> int"""
        return _blocks_swig4.peak_detector_fb_sptr_look_ahead(self)

    def alpha(self) -> "float":
        r"""alpha(peak_detector_fb_sptr self) -> float"""
        return _blocks_swig4.peak_detector_fb_sptr_alpha(self)

    def history(self) -> "unsigned int":
        r"""history(peak_detector_fb_sptr self) -> unsigned int"""
        return _blocks_swig4.peak_detector_fb_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(peak_detector_fb_sptr self, int which, int delay)
        declare_sample_delay(peak_detector_fb_sptr self, unsigned int delay)
        """
        return _blocks_swig4.peak_detector_fb_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(peak_detector_fb_sptr self, int which) -> unsigned int"""
        return _blocks_swig4.peak_detector_fb_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(peak_detector_fb_sptr self, int multiple)"""
        return _blocks_swig4.peak_detector_fb_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(peak_detector_fb_sptr self) -> int"""
        return _blocks_swig4.peak_detector_fb_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(peak_detector_fb_sptr self) -> double"""
        return _blocks_swig4.peak_detector_fb_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(peak_detector_fb_sptr self) -> uint64_t"""
        return _blocks_swig4.peak_detector_fb_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(peak_detector_fb_sptr self) -> uint64_t"""
        return _blocks_swig4.peak_detector_fb_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(peak_detector_fb_sptr self) -> bool"""
        return _blocks_swig4.peak_detector_fb_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(peak_detector_fb_sptr self) -> bool"""
        return _blocks_swig4.peak_detector_fb_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(peak_detector_fb_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig4.peak_detector_fb_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(peak_detector_fb_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig4.peak_detector_fb_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(peak_detector_fb_sptr self, std::string level)"""
        return _blocks_swig4.peak_detector_fb_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(peak_detector_fb_sptr self) -> std::string"""
        return _blocks_swig4.peak_detector_fb_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(peak_detector_fb_sptr self) -> int"""
        return _blocks_swig4.peak_detector_fb_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(peak_detector_fb_sptr self, int m)"""
        return _blocks_swig4.peak_detector_fb_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(peak_detector_fb_sptr self)"""
        return _blocks_swig4.peak_detector_fb_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(peak_detector_fb_sptr self) -> bool"""
        return _blocks_swig4.peak_detector_fb_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(peak_detector_fb_sptr self, int m)"""
        return _blocks_swig4.peak_detector_fb_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(peak_detector_fb_sptr self) -> int"""
        return _blocks_swig4.peak_detector_fb_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(peak_detector_fb_sptr self, int i) -> long"""
        return _blocks_swig4.peak_detector_fb_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(peak_detector_fb_sptr self, long max_output_buffer)
        set_max_output_buffer(peak_detector_fb_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig4.peak_detector_fb_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(peak_detector_fb_sptr self, int i) -> long"""
        return _blocks_swig4.peak_detector_fb_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(peak_detector_fb_sptr self, long min_output_buffer)
        set_min_output_buffer(peak_detector_fb_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig4.peak_detector_fb_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(peak_detector_fb_sptr self) -> float"""
        return _blocks_swig4.peak_detector_fb_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(peak_detector_fb_sptr self) -> float"""
        return _blocks_swig4.peak_detector_fb_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(peak_detector_fb_sptr self) -> float"""
        return _blocks_swig4.peak_detector_fb_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(peak_detector_fb_sptr self) -> float"""
        return _blocks_swig4.peak_detector_fb_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(peak_detector_fb_sptr self) -> float"""
        return _blocks_swig4.peak_detector_fb_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(peak_detector_fb_sptr self) -> float"""
        return _blocks_swig4.peak_detector_fb_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(peak_detector_fb_sptr self) -> float"""
        return _blocks_swig4.peak_detector_fb_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(peak_detector_fb_sptr self) -> float"""
        return _blocks_swig4.peak_detector_fb_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(peak_detector_fb_sptr self) -> float"""
        return _blocks_swig4.peak_detector_fb_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(peak_detector_fb_sptr self) -> float"""
        return _blocks_swig4.peak_detector_fb_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(peak_detector_fb_sptr self) -> float"""
        return _blocks_swig4.peak_detector_fb_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(peak_detector_fb_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig4.peak_detector_fb_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(peak_detector_fb_sptr self)"""
        return _blocks_swig4.peak_detector_fb_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(peak_detector_fb_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig4.peak_detector_fb_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(peak_detector_fb_sptr self) -> int"""
        return _blocks_swig4.peak_detector_fb_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(peak_detector_fb_sptr self) -> int"""
        return _blocks_swig4.peak_detector_fb_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(peak_detector_fb_sptr self, int priority) -> int"""
        return _blocks_swig4.peak_detector_fb_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(peak_detector_fb_sptr self) -> std::string"""
        return _blocks_swig4.peak_detector_fb_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(peak_detector_fb_sptr self) -> std::string"""
        return _blocks_swig4.peak_detector_fb_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(peak_detector_fb_sptr self) -> io_signature_sptr"""
        return _blocks_swig4.peak_detector_fb_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(peak_detector_fb_sptr self) -> io_signature_sptr"""
        return _blocks_swig4.peak_detector_fb_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(peak_detector_fb_sptr self) -> long"""
        return _blocks_swig4.peak_detector_fb_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(peak_detector_fb_sptr self) -> basic_block_sptr"""
        return _blocks_swig4.peak_detector_fb_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(peak_detector_fb_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig4.peak_detector_fb_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(peak_detector_fb_sptr self) -> std::string"""
        return _blocks_swig4.peak_detector_fb_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(peak_detector_fb_sptr self, std::string name)"""
        return _blocks_swig4.peak_detector_fb_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(peak_detector_fb_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig4.peak_detector_fb_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(peak_detector_fb_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig4.peak_detector_fb_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(peak_detector_fb_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig4.peak_detector_fb_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(peak_detector_fb_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig4.peak_detector_fb_sptr_message_subscribers(self, which_port)

# Register peak_detector_fb_sptr in _blocks_swig4:
_blocks_swig4.peak_detector_fb_sptr_swigregister(peak_detector_fb_sptr)


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

class peak_detector_ib(object):
    r"""Proxy of C++ gr::blocks::peak_detector< 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

    @staticmethod
    def make(threshold_factor_rise: "float"=0.25, threshold_factor_fall: "float"=0.40, look_ahead: "int"=10, alpha: "float"=0.001) -> "gr::blocks::peak_detector< int >::sptr":
        r"""make(float threshold_factor_rise=0.25, float threshold_factor_fall=0.40, int look_ahead=10, float alpha=0.001) -> peak_detector_ib_sptr"""
        return _blocks_swig4.peak_detector_ib_make(threshold_factor_rise, threshold_factor_fall, look_ahead, alpha)

    def set_threshold_factor_rise(self, thr: "float") -> "void":
        r"""set_threshold_factor_rise(peak_detector_ib self, float thr)"""
        return _blocks_swig4.peak_detector_ib_set_threshold_factor_rise(self, thr)

    def set_threshold_factor_fall(self, thr: "float") -> "void":
        r"""set_threshold_factor_fall(peak_detector_ib self, float thr)"""
        return _blocks_swig4.peak_detector_ib_set_threshold_factor_fall(self, thr)

    def set_look_ahead(self, look: "int") -> "void":
        r"""set_look_ahead(peak_detector_ib self, int look)"""
        return _blocks_swig4.peak_detector_ib_set_look_ahead(self, look)

    def set_alpha(self, alpha: "float") -> "void":
        r"""set_alpha(peak_detector_ib self, float alpha)"""
        return _blocks_swig4.peak_detector_ib_set_alpha(self, alpha)

    def threshold_factor_rise(self) -> "float":
        r"""threshold_factor_rise(peak_detector_ib self) -> float"""
        return _blocks_swig4.peak_detector_ib_threshold_factor_rise(self)

    def threshold_factor_fall(self) -> "float":
        r"""threshold_factor_fall(peak_detector_ib self) -> float"""
        return _blocks_swig4.peak_detector_ib_threshold_factor_fall(self)

    def look_ahead(self) -> "int":
        r"""look_ahead(peak_detector_ib self) -> int"""
        return _blocks_swig4.peak_detector_ib_look_ahead(self)

    def alpha(self) -> "float":
        r"""alpha(peak_detector_ib self) -> float"""
        return _blocks_swig4.peak_detector_ib_alpha(self)
    __swig_destroy__ = _blocks_swig4.delete_peak_detector_ib

# Register peak_detector_ib in _blocks_swig4:
_blocks_swig4.peak_detector_ib_swigregister(peak_detector_ib)

def peak_detector_ib_make(threshold_factor_rise: "float"=0.25, threshold_factor_fall: "float"=0.40, look_ahead: "int"=10, alpha: "float"=0.001) -> "gr::blocks::peak_detector< int >::sptr":
    r"""peak_detector_ib_make(float threshold_factor_rise=0.25, float threshold_factor_fall=0.40, int look_ahead=10, float alpha=0.001) -> peak_detector_ib_sptr"""
    return _blocks_swig4.peak_detector_ib_make(threshold_factor_rise, threshold_factor_fall, look_ahead, alpha)

class peak_detector_ib_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::peak_detector< 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__(peak_detector_ib_sptr self) -> peak_detector_ib_sptr
        __init__(peak_detector_ib_sptr self, peak_detector_ib p) -> peak_detector_ib_sptr
        """
        _blocks_swig4.peak_detector_ib_sptr_swiginit(self, _blocks_swig4.new_peak_detector_ib_sptr(*args))

    def __deref__(self) -> "gr::blocks::peak_detector< std::int32_t > *":
        r"""__deref__(peak_detector_ib_sptr self) -> peak_detector_ib"""
        return _blocks_swig4.peak_detector_ib_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig4.delete_peak_detector_ib_sptr

    def make(self, threshold_factor_rise: "float"=0.25, threshold_factor_fall: "float"=0.40, look_ahead: "int"=10, alpha: "float"=0.001) -> "gr::blocks::peak_detector< int >::sptr":
        r"""make(peak_detector_ib_sptr self, float threshold_factor_rise=0.25, float threshold_factor_fall=0.40, int look_ahead=10, float alpha=0.001) -> peak_detector_ib_sptr"""
        return _blocks_swig4.peak_detector_ib_sptr_make(self, threshold_factor_rise, threshold_factor_fall, look_ahead, alpha)

    def set_threshold_factor_rise(self, thr: "float") -> "void":
        r"""set_threshold_factor_rise(peak_detector_ib_sptr self, float thr)"""
        return _blocks_swig4.peak_detector_ib_sptr_set_threshold_factor_rise(self, thr)

    def set_threshold_factor_fall(self, thr: "float") -> "void":
        r"""set_threshold_factor_fall(peak_detector_ib_sptr self, float thr)"""
        return _blocks_swig4.peak_detector_ib_sptr_set_threshold_factor_fall(self, thr)

    def set_look_ahead(self, look: "int") -> "void":
        r"""set_look_ahead(peak_detector_ib_sptr self, int look)"""
        return _blocks_swig4.peak_detector_ib_sptr_set_look_ahead(self, look)

    def set_alpha(self, alpha: "float") -> "void":
        r"""set_alpha(peak_detector_ib_sptr self, float alpha)"""
        return _blocks_swig4.peak_detector_ib_sptr_set_alpha(self, alpha)

    def threshold_factor_rise(self) -> "float":
        r"""threshold_factor_rise(peak_detector_ib_sptr self) -> float"""
        return _blocks_swig4.peak_detector_ib_sptr_threshold_factor_rise(self)

    def threshold_factor_fall(self) -> "float":
        r"""threshold_factor_fall(peak_detector_ib_sptr self) -> float"""
        return _blocks_swig4.peak_detector_ib_sptr_threshold_factor_fall(self)

    def look_ahead(self) -> "int":
        r"""look_ahead(peak_detector_ib_sptr self) -> int"""
        return _blocks_swig4.peak_detector_ib_sptr_look_ahead(self)

    def alpha(self) -> "float":
        r"""alpha(peak_detector_ib_sptr self) -> float"""
        return _blocks_swig4.peak_detector_ib_sptr_alpha(self)

    def history(self) -> "unsigned int":
        r"""history(peak_detector_ib_sptr self) -> unsigned int"""
        return _blocks_swig4.peak_detector_ib_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(peak_detector_ib_sptr self, int which, int delay)
        declare_sample_delay(peak_detector_ib_sptr self, unsigned int delay)
        """
        return _blocks_swig4.peak_detector_ib_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(peak_detector_ib_sptr self, int which) -> unsigned int"""
        return _blocks_swig4.peak_detector_ib_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(peak_detector_ib_sptr self, int multiple)"""
        return _blocks_swig4.peak_detector_ib_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(peak_detector_ib_sptr self) -> int"""
        return _blocks_swig4.peak_detector_ib_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(peak_detector_ib_sptr self) -> double"""
        return _blocks_swig4.peak_detector_ib_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(peak_detector_ib_sptr self) -> uint64_t"""
        return _blocks_swig4.peak_detector_ib_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(peak_detector_ib_sptr self) -> uint64_t"""
        return _blocks_swig4.peak_detector_ib_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(peak_detector_ib_sptr self) -> bool"""
        return _blocks_swig4.peak_detector_ib_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(peak_detector_ib_sptr self) -> bool"""
        return _blocks_swig4.peak_detector_ib_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(peak_detector_ib_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig4.peak_detector_ib_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(peak_detector_ib_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig4.peak_detector_ib_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(peak_detector_ib_sptr self, std::string level)"""
        return _blocks_swig4.peak_detector_ib_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(peak_detector_ib_sptr self) -> std::string"""
        return _blocks_swig4.peak_detector_ib_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(peak_detector_ib_sptr self) -> int"""
        return _blocks_swig4.peak_detector_ib_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(peak_detector_ib_sptr self, int m)"""
        return _blocks_swig4.peak_detector_ib_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(peak_detector_ib_sptr self)"""
        return _blocks_swig4.peak_detector_ib_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(peak_detector_ib_sptr self) -> bool"""
        return _blocks_swig4.peak_detector_ib_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(peak_detector_ib_sptr self, int m)"""
        return _blocks_swig4.peak_detector_ib_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(peak_detector_ib_sptr self) -> int"""
        return _blocks_swig4.peak_detector_ib_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(peak_detector_ib_sptr self, int i) -> long"""
        return _blocks_swig4.peak_detector_ib_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(peak_detector_ib_sptr self, long max_output_buffer)
        set_max_output_buffer(peak_detector_ib_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig4.peak_detector_ib_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(peak_detector_ib_sptr self, int i) -> long"""
        return _blocks_swig4.peak_detector_ib_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(peak_detector_ib_sptr self, long min_output_buffer)
        set_min_output_buffer(peak_detector_ib_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig4.peak_detector_ib_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(peak_detector_ib_sptr self) -> float"""
        return _blocks_swig4.peak_detector_ib_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(peak_detector_ib_sptr self) -> float"""
        return _blocks_swig4.peak_detector_ib_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(peak_detector_ib_sptr self) -> float"""
        return _blocks_swig4.peak_detector_ib_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(peak_detector_ib_sptr self) -> float"""
        return _blocks_swig4.peak_detector_ib_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(peak_detector_ib_sptr self) -> float"""
        return _blocks_swig4.peak_detector_ib_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(peak_detector_ib_sptr self) -> float"""
        return _blocks_swig4.peak_detector_ib_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(peak_detector_ib_sptr self) -> float"""
        return _blocks_swig4.peak_detector_ib_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(peak_detector_ib_sptr self) -> float"""
        return _blocks_swig4.peak_detector_ib_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(peak_detector_ib_sptr self) -> float"""
        return _blocks_swig4.peak_detector_ib_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(peak_detector_ib_sptr self) -> float"""
        return _blocks_swig4.peak_detector_ib_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(peak_detector_ib_sptr self) -> float"""
        return _blocks_swig4.peak_detector_ib_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(peak_detector_ib_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig4.peak_detector_ib_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(peak_detector_ib_sptr self)"""
        return _blocks_swig4.peak_detector_ib_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(peak_detector_ib_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig4.peak_detector_ib_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(peak_detector_ib_sptr self) -> int"""
        return _blocks_swig4.peak_detector_ib_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(peak_detector_ib_sptr self) -> int"""
        return _blocks_swig4.peak_detector_ib_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(peak_detector_ib_sptr self, int priority) -> int"""
        return _blocks_swig4.peak_detector_ib_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(peak_detector_ib_sptr self) -> std::string"""
        return _blocks_swig4.peak_detector_ib_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(peak_detector_ib_sptr self) -> std::string"""
        return _blocks_swig4.peak_detector_ib_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(peak_detector_ib_sptr self) -> io_signature_sptr"""
        return _blocks_swig4.peak_detector_ib_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(peak_detector_ib_sptr self) -> io_signature_sptr"""
        return _blocks_swig4.peak_detector_ib_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(peak_detector_ib_sptr self) -> long"""
        return _blocks_swig4.peak_detector_ib_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(peak_detector_ib_sptr self) -> basic_block_sptr"""
        return _blocks_swig4.peak_detector_ib_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(peak_detector_ib_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig4.peak_detector_ib_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(peak_detector_ib_sptr self) -> std::string"""
        return _blocks_swig4.peak_detector_ib_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(peak_detector_ib_sptr self, std::string name)"""
        return _blocks_swig4.peak_detector_ib_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(peak_detector_ib_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig4.peak_detector_ib_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(peak_detector_ib_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig4.peak_detector_ib_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(peak_detector_ib_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig4.peak_detector_ib_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(peak_detector_ib_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig4.peak_detector_ib_sptr_message_subscribers(self, which_port)

# Register peak_detector_ib_sptr in _blocks_swig4:
_blocks_swig4.peak_detector_ib_sptr_swigregister(peak_detector_ib_sptr)


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

class peak_detector_sb(object):
    r"""Proxy of C++ gr::blocks::peak_detector< 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

    @staticmethod
    def make(threshold_factor_rise: "float"=0.25, threshold_factor_fall: "float"=0.40, look_ahead: "int"=10, alpha: "float"=0.001) -> "gr::blocks::peak_detector< short >::sptr":
        r"""make(float threshold_factor_rise=0.25, float threshold_factor_fall=0.40, int look_ahead=10, float alpha=0.001) -> peak_detector_sb_sptr"""
        return _blocks_swig4.peak_detector_sb_make(threshold_factor_rise, threshold_factor_fall, look_ahead, alpha)

    def set_threshold_factor_rise(self, thr: "float") -> "void":
        r"""set_threshold_factor_rise(peak_detector_sb self, float thr)"""
        return _blocks_swig4.peak_detector_sb_set_threshold_factor_rise(self, thr)

    def set_threshold_factor_fall(self, thr: "float") -> "void":
        r"""set_threshold_factor_fall(peak_detector_sb self, float thr)"""
        return _blocks_swig4.peak_detector_sb_set_threshold_factor_fall(self, thr)

    def set_look_ahead(self, look: "int") -> "void":
        r"""set_look_ahead(peak_detector_sb self, int look)"""
        return _blocks_swig4.peak_detector_sb_set_look_ahead(self, look)

    def set_alpha(self, alpha: "float") -> "void":
        r"""set_alpha(peak_detector_sb self, float alpha)"""
        return _blocks_swig4.peak_detector_sb_set_alpha(self, alpha)

    def threshold_factor_rise(self) -> "float":
        r"""threshold_factor_rise(peak_detector_sb self) -> float"""
        return _blocks_swig4.peak_detector_sb_threshold_factor_rise(self)

    def threshold_factor_fall(self) -> "float":
        r"""threshold_factor_fall(peak_detector_sb self) -> float"""
        return _blocks_swig4.peak_detector_sb_threshold_factor_fall(self)

    def look_ahead(self) -> "int":
        r"""look_ahead(peak_detector_sb self) -> int"""
        return _blocks_swig4.peak_detector_sb_look_ahead(self)

    def alpha(self) -> "float":
        r"""alpha(peak_detector_sb self) -> float"""
        return _blocks_swig4.peak_detector_sb_alpha(self)
    __swig_destroy__ = _blocks_swig4.delete_peak_detector_sb

# Register peak_detector_sb in _blocks_swig4:
_blocks_swig4.peak_detector_sb_swigregister(peak_detector_sb)

def peak_detector_sb_make(threshold_factor_rise: "float"=0.25, threshold_factor_fall: "float"=0.40, look_ahead: "int"=10, alpha: "float"=0.001) -> "gr::blocks::peak_detector< short >::sptr":
    r"""peak_detector_sb_make(float threshold_factor_rise=0.25, float threshold_factor_fall=0.40, int look_ahead=10, float alpha=0.001) -> peak_detector_sb_sptr"""
    return _blocks_swig4.peak_detector_sb_make(threshold_factor_rise, threshold_factor_fall, look_ahead, alpha)

class peak_detector_sb_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::peak_detector< 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__(peak_detector_sb_sptr self) -> peak_detector_sb_sptr
        __init__(peak_detector_sb_sptr self, peak_detector_sb p) -> peak_detector_sb_sptr
        """
        _blocks_swig4.peak_detector_sb_sptr_swiginit(self, _blocks_swig4.new_peak_detector_sb_sptr(*args))

    def __deref__(self) -> "gr::blocks::peak_detector< std::int16_t > *":
        r"""__deref__(peak_detector_sb_sptr self) -> peak_detector_sb"""
        return _blocks_swig4.peak_detector_sb_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig4.delete_peak_detector_sb_sptr

    def make(self, threshold_factor_rise: "float"=0.25, threshold_factor_fall: "float"=0.40, look_ahead: "int"=10, alpha: "float"=0.001) -> "gr::blocks::peak_detector< short >::sptr":
        r"""make(peak_detector_sb_sptr self, float threshold_factor_rise=0.25, float threshold_factor_fall=0.40, int look_ahead=10, float alpha=0.001) -> peak_detector_sb_sptr"""
        return _blocks_swig4.peak_detector_sb_sptr_make(self, threshold_factor_rise, threshold_factor_fall, look_ahead, alpha)

    def set_threshold_factor_rise(self, thr: "float") -> "void":
        r"""set_threshold_factor_rise(peak_detector_sb_sptr self, float thr)"""
        return _blocks_swig4.peak_detector_sb_sptr_set_threshold_factor_rise(self, thr)

    def set_threshold_factor_fall(self, thr: "float") -> "void":
        r"""set_threshold_factor_fall(peak_detector_sb_sptr self, float thr)"""
        return _blocks_swig4.peak_detector_sb_sptr_set_threshold_factor_fall(self, thr)

    def set_look_ahead(self, look: "int") -> "void":
        r"""set_look_ahead(peak_detector_sb_sptr self, int look)"""
        return _blocks_swig4.peak_detector_sb_sptr_set_look_ahead(self, look)

    def set_alpha(self, alpha: "float") -> "void":
        r"""set_alpha(peak_detector_sb_sptr self, float alpha)"""
        return _blocks_swig4.peak_detector_sb_sptr_set_alpha(self, alpha)

    def threshold_factor_rise(self) -> "float":
        r"""threshold_factor_rise(peak_detector_sb_sptr self) -> float"""
        return _blocks_swig4.peak_detector_sb_sptr_threshold_factor_rise(self)

    def threshold_factor_fall(self) -> "float":
        r"""threshold_factor_fall(peak_detector_sb_sptr self) -> float"""
        return _blocks_swig4.peak_detector_sb_sptr_threshold_factor_fall(self)

    def look_ahead(self) -> "int":
        r"""look_ahead(peak_detector_sb_sptr self) -> int"""
        return _blocks_swig4.peak_detector_sb_sptr_look_ahead(self)

    def alpha(self) -> "float":
        r"""alpha(peak_detector_sb_sptr self) -> float"""
        return _blocks_swig4.peak_detector_sb_sptr_alpha(self)

    def history(self) -> "unsigned int":
        r"""history(peak_detector_sb_sptr self) -> unsigned int"""
        return _blocks_swig4.peak_detector_sb_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(peak_detector_sb_sptr self, int which, int delay)
        declare_sample_delay(peak_detector_sb_sptr self, unsigned int delay)
        """
        return _blocks_swig4.peak_detector_sb_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(peak_detector_sb_sptr self, int which) -> unsigned int"""
        return _blocks_swig4.peak_detector_sb_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(peak_detector_sb_sptr self, int multiple)"""
        return _blocks_swig4.peak_detector_sb_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(peak_detector_sb_sptr self) -> int"""
        return _blocks_swig4.peak_detector_sb_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(peak_detector_sb_sptr self) -> double"""
        return _blocks_swig4.peak_detector_sb_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(peak_detector_sb_sptr self) -> uint64_t"""
        return _blocks_swig4.peak_detector_sb_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(peak_detector_sb_sptr self) -> uint64_t"""
        return _blocks_swig4.peak_detector_sb_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(peak_detector_sb_sptr self) -> bool"""
        return _blocks_swig4.peak_detector_sb_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(peak_detector_sb_sptr self) -> bool"""
        return _blocks_swig4.peak_detector_sb_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(peak_detector_sb_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig4.peak_detector_sb_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(peak_detector_sb_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig4.peak_detector_sb_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(peak_detector_sb_sptr self, std::string level)"""
        return _blocks_swig4.peak_detector_sb_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(peak_detector_sb_sptr self) -> std::string"""
        return _blocks_swig4.peak_detector_sb_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(peak_detector_sb_sptr self) -> int"""
        return _blocks_swig4.peak_detector_sb_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(peak_detector_sb_sptr self, int m)"""
        return _blocks_swig4.peak_detector_sb_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(peak_detector_sb_sptr self)"""
        return _blocks_swig4.peak_detector_sb_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(peak_detector_sb_sptr self) -> bool"""
        return _blocks_swig4.peak_detector_sb_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(peak_detector_sb_sptr self, int m)"""
        return _blocks_swig4.peak_detector_sb_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(peak_detector_sb_sptr self) -> int"""
        return _blocks_swig4.peak_detector_sb_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(peak_detector_sb_sptr self, int i) -> long"""
        return _blocks_swig4.peak_detector_sb_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(peak_detector_sb_sptr self, long max_output_buffer)
        set_max_output_buffer(peak_detector_sb_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig4.peak_detector_sb_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(peak_detector_sb_sptr self, int i) -> long"""
        return _blocks_swig4.peak_detector_sb_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(peak_detector_sb_sptr self, long min_output_buffer)
        set_min_output_buffer(peak_detector_sb_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig4.peak_detector_sb_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(peak_detector_sb_sptr self) -> float"""
        return _blocks_swig4.peak_detector_sb_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(peak_detector_sb_sptr self) -> float"""
        return _blocks_swig4.peak_detector_sb_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(peak_detector_sb_sptr self) -> float"""
        return _blocks_swig4.peak_detector_sb_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(peak_detector_sb_sptr self) -> float"""
        return _blocks_swig4.peak_detector_sb_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(peak_detector_sb_sptr self) -> float"""
        return _blocks_swig4.peak_detector_sb_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(peak_detector_sb_sptr self) -> float"""
        return _blocks_swig4.peak_detector_sb_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(peak_detector_sb_sptr self) -> float"""
        return _blocks_swig4.peak_detector_sb_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(peak_detector_sb_sptr self) -> float"""
        return _blocks_swig4.peak_detector_sb_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(peak_detector_sb_sptr self) -> float"""
        return _blocks_swig4.peak_detector_sb_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(peak_detector_sb_sptr self) -> float"""
        return _blocks_swig4.peak_detector_sb_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(peak_detector_sb_sptr self) -> float"""
        return _blocks_swig4.peak_detector_sb_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(peak_detector_sb_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig4.peak_detector_sb_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(peak_detector_sb_sptr self)"""
        return _blocks_swig4.peak_detector_sb_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(peak_detector_sb_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig4.peak_detector_sb_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(peak_detector_sb_sptr self) -> int"""
        return _blocks_swig4.peak_detector_sb_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(peak_detector_sb_sptr self) -> int"""
        return _blocks_swig4.peak_detector_sb_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(peak_detector_sb_sptr self, int priority) -> int"""
        return _blocks_swig4.peak_detector_sb_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(peak_detector_sb_sptr self) -> std::string"""
        return _blocks_swig4.peak_detector_sb_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(peak_detector_sb_sptr self) -> std::string"""
        return _blocks_swig4.peak_detector_sb_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(peak_detector_sb_sptr self) -> io_signature_sptr"""
        return _blocks_swig4.peak_detector_sb_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(peak_detector_sb_sptr self) -> io_signature_sptr"""
        return _blocks_swig4.peak_detector_sb_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(peak_detector_sb_sptr self) -> long"""
        return _blocks_swig4.peak_detector_sb_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(peak_detector_sb_sptr self) -> basic_block_sptr"""
        return _blocks_swig4.peak_detector_sb_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(peak_detector_sb_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig4.peak_detector_sb_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(peak_detector_sb_sptr self) -> std::string"""
        return _blocks_swig4.peak_detector_sb_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(peak_detector_sb_sptr self, std::string name)"""
        return _blocks_swig4.peak_detector_sb_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(peak_detector_sb_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig4.peak_detector_sb_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(peak_detector_sb_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig4.peak_detector_sb_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(peak_detector_sb_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig4.peak_detector_sb_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(peak_detector_sb_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig4.peak_detector_sb_sptr_message_subscribers(self, which_port)

# Register peak_detector_sb_sptr in _blocks_swig4:
_blocks_swig4.peak_detector_sb_sptr_swigregister(peak_detector_sb_sptr)


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

class peak_detector2_fb_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::peak_detector2_fb > 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__(peak_detector2_fb_sptr self) -> peak_detector2_fb_sptr
        __init__(peak_detector2_fb_sptr self, peak_detector2_fb p) -> peak_detector2_fb_sptr
        """
        _blocks_swig4.peak_detector2_fb_sptr_swiginit(self, _blocks_swig4.new_peak_detector2_fb_sptr(*args))

    def __deref__(self) -> "gr::blocks::peak_detector2_fb *":
        r"""__deref__(peak_detector2_fb_sptr self) -> peak_detector2_fb"""
        return _blocks_swig4.peak_detector2_fb_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig4.delete_peak_detector2_fb_sptr

    def make(self, threshold_factor_rise: "float"=7, look_ahead: "int"=1000, alpha: "float"=0.001) -> "gr::blocks::peak_detector2_fb::sptr":
        r"""make(peak_detector2_fb_sptr self, float threshold_factor_rise=7, int look_ahead=1000, float alpha=0.001) -> peak_detector2_fb_sptr"""
        return _blocks_swig4.peak_detector2_fb_sptr_make(self, threshold_factor_rise, look_ahead, alpha)

    def set_threshold_factor_rise(self, thr: "float") -> "void":
        r"""set_threshold_factor_rise(peak_detector2_fb_sptr self, float thr)"""
        return _blocks_swig4.peak_detector2_fb_sptr_set_threshold_factor_rise(self, thr)

    def set_look_ahead(self, look: "int") -> "void":
        r"""set_look_ahead(peak_detector2_fb_sptr self, int look)"""
        return _blocks_swig4.peak_detector2_fb_sptr_set_look_ahead(self, look)

    def set_alpha(self, alpha: "float") -> "void":
        r"""set_alpha(peak_detector2_fb_sptr self, float alpha)"""
        return _blocks_swig4.peak_detector2_fb_sptr_set_alpha(self, alpha)

    def threshold_factor_rise(self) -> "float":
        r"""threshold_factor_rise(peak_detector2_fb_sptr self) -> float"""
        return _blocks_swig4.peak_detector2_fb_sptr_threshold_factor_rise(self)

    def look_ahead(self) -> "int":
        r"""look_ahead(peak_detector2_fb_sptr self) -> int"""
        return _blocks_swig4.peak_detector2_fb_sptr_look_ahead(self)

    def alpha(self) -> "float":
        r"""alpha(peak_detector2_fb_sptr self) -> float"""
        return _blocks_swig4.peak_detector2_fb_sptr_alpha(self)

    def history(self) -> "unsigned int":
        r"""history(peak_detector2_fb_sptr self) -> unsigned int"""
        return _blocks_swig4.peak_detector2_fb_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(peak_detector2_fb_sptr self, int which, int delay)
        declare_sample_delay(peak_detector2_fb_sptr self, unsigned int delay)
        """
        return _blocks_swig4.peak_detector2_fb_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(peak_detector2_fb_sptr self, int which) -> unsigned int"""
        return _blocks_swig4.peak_detector2_fb_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(peak_detector2_fb_sptr self, int multiple)"""
        return _blocks_swig4.peak_detector2_fb_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(peak_detector2_fb_sptr self) -> int"""
        return _blocks_swig4.peak_detector2_fb_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(peak_detector2_fb_sptr self) -> double"""
        return _blocks_swig4.peak_detector2_fb_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(peak_detector2_fb_sptr self) -> uint64_t"""
        return _blocks_swig4.peak_detector2_fb_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(peak_detector2_fb_sptr self) -> uint64_t"""
        return _blocks_swig4.peak_detector2_fb_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(peak_detector2_fb_sptr self) -> bool"""
        return _blocks_swig4.peak_detector2_fb_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(peak_detector2_fb_sptr self) -> bool"""
        return _blocks_swig4.peak_detector2_fb_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(peak_detector2_fb_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig4.peak_detector2_fb_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(peak_detector2_fb_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig4.peak_detector2_fb_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(peak_detector2_fb_sptr self, std::string level)"""
        return _blocks_swig4.peak_detector2_fb_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(peak_detector2_fb_sptr self) -> std::string"""
        return _blocks_swig4.peak_detector2_fb_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(peak_detector2_fb_sptr self) -> int"""
        return _blocks_swig4.peak_detector2_fb_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(peak_detector2_fb_sptr self, int m)"""
        return _blocks_swig4.peak_detector2_fb_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(peak_detector2_fb_sptr self)"""
        return _blocks_swig4.peak_detector2_fb_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(peak_detector2_fb_sptr self) -> bool"""
        return _blocks_swig4.peak_detector2_fb_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(peak_detector2_fb_sptr self, int m)"""
        return _blocks_swig4.peak_detector2_fb_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(peak_detector2_fb_sptr self) -> int"""
        return _blocks_swig4.peak_detector2_fb_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(peak_detector2_fb_sptr self, int i) -> long"""
        return _blocks_swig4.peak_detector2_fb_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(peak_detector2_fb_sptr self, long max_output_buffer)
        set_max_output_buffer(peak_detector2_fb_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig4.peak_detector2_fb_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(peak_detector2_fb_sptr self, int i) -> long"""
        return _blocks_swig4.peak_detector2_fb_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(peak_detector2_fb_sptr self, long min_output_buffer)
        set_min_output_buffer(peak_detector2_fb_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig4.peak_detector2_fb_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(peak_detector2_fb_sptr self) -> float"""
        return _blocks_swig4.peak_detector2_fb_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(peak_detector2_fb_sptr self) -> float"""
        return _blocks_swig4.peak_detector2_fb_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(peak_detector2_fb_sptr self) -> float"""
        return _blocks_swig4.peak_detector2_fb_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(peak_detector2_fb_sptr self) -> float"""
        return _blocks_swig4.peak_detector2_fb_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(peak_detector2_fb_sptr self) -> float"""
        return _blocks_swig4.peak_detector2_fb_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(peak_detector2_fb_sptr self) -> float"""
        return _blocks_swig4.peak_detector2_fb_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(peak_detector2_fb_sptr self) -> float"""
        return _blocks_swig4.peak_detector2_fb_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(peak_detector2_fb_sptr self) -> float"""
        return _blocks_swig4.peak_detector2_fb_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(peak_detector2_fb_sptr self) -> float"""
        return _blocks_swig4.peak_detector2_fb_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(peak_detector2_fb_sptr self) -> float"""
        return _blocks_swig4.peak_detector2_fb_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(peak_detector2_fb_sptr self) -> float"""
        return _blocks_swig4.peak_detector2_fb_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(peak_detector2_fb_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig4.peak_detector2_fb_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(peak_detector2_fb_sptr self)"""
        return _blocks_swig4.peak_detector2_fb_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(peak_detector2_fb_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig4.peak_detector2_fb_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(peak_detector2_fb_sptr self) -> int"""
        return _blocks_swig4.peak_detector2_fb_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(peak_detector2_fb_sptr self) -> int"""
        return _blocks_swig4.peak_detector2_fb_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(peak_detector2_fb_sptr self, int priority) -> int"""
        return _blocks_swig4.peak_detector2_fb_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(peak_detector2_fb_sptr self) -> std::string"""
        return _blocks_swig4.peak_detector2_fb_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(peak_detector2_fb_sptr self) -> std::string"""
        return _blocks_swig4.peak_detector2_fb_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(peak_detector2_fb_sptr self) -> io_signature_sptr"""
        return _blocks_swig4.peak_detector2_fb_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(peak_detector2_fb_sptr self) -> io_signature_sptr"""
        return _blocks_swig4.peak_detector2_fb_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(peak_detector2_fb_sptr self) -> long"""
        return _blocks_swig4.peak_detector2_fb_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(peak_detector2_fb_sptr self) -> basic_block_sptr"""
        return _blocks_swig4.peak_detector2_fb_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(peak_detector2_fb_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig4.peak_detector2_fb_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(peak_detector2_fb_sptr self) -> std::string"""
        return _blocks_swig4.peak_detector2_fb_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(peak_detector2_fb_sptr self, std::string name)"""
        return _blocks_swig4.peak_detector2_fb_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(peak_detector2_fb_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig4.peak_detector2_fb_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(peak_detector2_fb_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig4.peak_detector2_fb_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(peak_detector2_fb_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig4.peak_detector2_fb_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(peak_detector2_fb_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig4.peak_detector2_fb_sptr_message_subscribers(self, which_port)

# Register peak_detector2_fb_sptr in _blocks_swig4:
_blocks_swig4.peak_detector2_fb_sptr_swigregister(peak_detector2_fb_sptr)


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

class plateau_detector_fb_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::plateau_detector_fb > 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__(plateau_detector_fb_sptr self) -> plateau_detector_fb_sptr
        __init__(plateau_detector_fb_sptr self, plateau_detector_fb p) -> plateau_detector_fb_sptr
        """
        _blocks_swig4.plateau_detector_fb_sptr_swiginit(self, _blocks_swig4.new_plateau_detector_fb_sptr(*args))

    def __deref__(self) -> "gr::blocks::plateau_detector_fb *":
        r"""__deref__(plateau_detector_fb_sptr self) -> plateau_detector_fb"""
        return _blocks_swig4.plateau_detector_fb_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig4.delete_plateau_detector_fb_sptr

    def make(self, max_len: "int", threshold: "float"=0.9) -> "gr::blocks::plateau_detector_fb::sptr":
        r"""make(plateau_detector_fb_sptr self, int max_len, float threshold=0.9) -> plateau_detector_fb_sptr"""
        return _blocks_swig4.plateau_detector_fb_sptr_make(self, max_len, threshold)

    def set_threshold(self, threshold: "float") -> "void":
        r"""set_threshold(plateau_detector_fb_sptr self, float threshold)"""
        return _blocks_swig4.plateau_detector_fb_sptr_set_threshold(self, threshold)

    def threshold(self) -> "float":
        r"""threshold(plateau_detector_fb_sptr self) -> float"""
        return _blocks_swig4.plateau_detector_fb_sptr_threshold(self)

    def history(self) -> "unsigned int":
        r"""history(plateau_detector_fb_sptr self) -> unsigned int"""
        return _blocks_swig4.plateau_detector_fb_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(plateau_detector_fb_sptr self, int which, int delay)
        declare_sample_delay(plateau_detector_fb_sptr self, unsigned int delay)
        """
        return _blocks_swig4.plateau_detector_fb_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(plateau_detector_fb_sptr self, int which) -> unsigned int"""
        return _blocks_swig4.plateau_detector_fb_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(plateau_detector_fb_sptr self, int multiple)"""
        return _blocks_swig4.plateau_detector_fb_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(plateau_detector_fb_sptr self) -> int"""
        return _blocks_swig4.plateau_detector_fb_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(plateau_detector_fb_sptr self) -> double"""
        return _blocks_swig4.plateau_detector_fb_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(plateau_detector_fb_sptr self) -> uint64_t"""
        return _blocks_swig4.plateau_detector_fb_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(plateau_detector_fb_sptr self) -> uint64_t"""
        return _blocks_swig4.plateau_detector_fb_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(plateau_detector_fb_sptr self) -> bool"""
        return _blocks_swig4.plateau_detector_fb_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(plateau_detector_fb_sptr self) -> bool"""
        return _blocks_swig4.plateau_detector_fb_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(plateau_detector_fb_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig4.plateau_detector_fb_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(plateau_detector_fb_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig4.plateau_detector_fb_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(plateau_detector_fb_sptr self, std::string level)"""
        return _blocks_swig4.plateau_detector_fb_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(plateau_detector_fb_sptr self) -> std::string"""
        return _blocks_swig4.plateau_detector_fb_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(plateau_detector_fb_sptr self) -> int"""
        return _blocks_swig4.plateau_detector_fb_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(plateau_detector_fb_sptr self, int m)"""
        return _blocks_swig4.plateau_detector_fb_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(plateau_detector_fb_sptr self)"""
        return _blocks_swig4.plateau_detector_fb_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(plateau_detector_fb_sptr self) -> bool"""
        return _blocks_swig4.plateau_detector_fb_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(plateau_detector_fb_sptr self, int m)"""
        return _blocks_swig4.plateau_detector_fb_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(plateau_detector_fb_sptr self) -> int"""
        return _blocks_swig4.plateau_detector_fb_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(plateau_detector_fb_sptr self, int i) -> long"""
        return _blocks_swig4.plateau_detector_fb_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(plateau_detector_fb_sptr self, long max_output_buffer)
        set_max_output_buffer(plateau_detector_fb_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig4.plateau_detector_fb_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(plateau_detector_fb_sptr self, int i) -> long"""
        return _blocks_swig4.plateau_detector_fb_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(plateau_detector_fb_sptr self, long min_output_buffer)
        set_min_output_buffer(plateau_detector_fb_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig4.plateau_detector_fb_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(plateau_detector_fb_sptr self) -> float"""
        return _blocks_swig4.plateau_detector_fb_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(plateau_detector_fb_sptr self) -> float"""
        return _blocks_swig4.plateau_detector_fb_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(plateau_detector_fb_sptr self) -> float"""
        return _blocks_swig4.plateau_detector_fb_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(plateau_detector_fb_sptr self) -> float"""
        return _blocks_swig4.plateau_detector_fb_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(plateau_detector_fb_sptr self) -> float"""
        return _blocks_swig4.plateau_detector_fb_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(plateau_detector_fb_sptr self) -> float"""
        return _blocks_swig4.plateau_detector_fb_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(plateau_detector_fb_sptr self) -> float"""
        return _blocks_swig4.plateau_detector_fb_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(plateau_detector_fb_sptr self) -> float"""
        return _blocks_swig4.plateau_detector_fb_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(plateau_detector_fb_sptr self) -> float"""
        return _blocks_swig4.plateau_detector_fb_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(plateau_detector_fb_sptr self) -> float"""
        return _blocks_swig4.plateau_detector_fb_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(plateau_detector_fb_sptr self) -> float"""
        return _blocks_swig4.plateau_detector_fb_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(plateau_detector_fb_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig4.plateau_detector_fb_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(plateau_detector_fb_sptr self)"""
        return _blocks_swig4.plateau_detector_fb_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(plateau_detector_fb_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig4.plateau_detector_fb_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(plateau_detector_fb_sptr self) -> int"""
        return _blocks_swig4.plateau_detector_fb_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(plateau_detector_fb_sptr self) -> int"""
        return _blocks_swig4.plateau_detector_fb_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(plateau_detector_fb_sptr self, int priority) -> int"""
        return _blocks_swig4.plateau_detector_fb_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(plateau_detector_fb_sptr self) -> std::string"""
        return _blocks_swig4.plateau_detector_fb_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(plateau_detector_fb_sptr self) -> std::string"""
        return _blocks_swig4.plateau_detector_fb_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(plateau_detector_fb_sptr self) -> io_signature_sptr"""
        return _blocks_swig4.plateau_detector_fb_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(plateau_detector_fb_sptr self) -> io_signature_sptr"""
        return _blocks_swig4.plateau_detector_fb_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(plateau_detector_fb_sptr self) -> long"""
        return _blocks_swig4.plateau_detector_fb_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(plateau_detector_fb_sptr self) -> basic_block_sptr"""
        return _blocks_swig4.plateau_detector_fb_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(plateau_detector_fb_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig4.plateau_detector_fb_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(plateau_detector_fb_sptr self) -> std::string"""
        return _blocks_swig4.plateau_detector_fb_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(plateau_detector_fb_sptr self, std::string name)"""
        return _blocks_swig4.plateau_detector_fb_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(plateau_detector_fb_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig4.plateau_detector_fb_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(plateau_detector_fb_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig4.plateau_detector_fb_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(plateau_detector_fb_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig4.plateau_detector_fb_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(plateau_detector_fb_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig4.plateau_detector_fb_sptr_message_subscribers(self, which_port)

# Register plateau_detector_fb_sptr in _blocks_swig4:
_blocks_swig4.plateau_detector_fb_sptr_swigregister(plateau_detector_fb_sptr)


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

class pdu_filter_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::pdu_filter > 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__(pdu_filter_sptr self) -> pdu_filter_sptr
        __init__(pdu_filter_sptr self, pdu_filter p) -> pdu_filter_sptr
        """
        _blocks_swig4.pdu_filter_sptr_swiginit(self, _blocks_swig4.new_pdu_filter_sptr(*args))

    def __deref__(self) -> "gr::blocks::pdu_filter *":
        r"""__deref__(pdu_filter_sptr self) -> pdu_filter"""
        return _blocks_swig4.pdu_filter_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig4.delete_pdu_filter_sptr

    def make(self, k: "swig_pmt_ptr", v: "swig_pmt_ptr", invert: "bool"=False) -> "gr::blocks::pdu_filter::sptr":
        r"""make(pdu_filter_sptr self, swig_pmt_ptr k, swig_pmt_ptr v, bool invert=False) -> pdu_filter_sptr"""
        return _blocks_swig4.pdu_filter_sptr_make(self, k, v, invert)

    def set_key(self, key: "swig_pmt_ptr") -> "void":
        r"""set_key(pdu_filter_sptr self, swig_pmt_ptr key)"""
        return _blocks_swig4.pdu_filter_sptr_set_key(self, key)

    def set_val(self, val: "swig_pmt_ptr") -> "void":
        r"""set_val(pdu_filter_sptr self, swig_pmt_ptr val)"""
        return _blocks_swig4.pdu_filter_sptr_set_val(self, val)

    def set_inversion(self, invert: "bool") -> "void":
        r"""set_inversion(pdu_filter_sptr self, bool invert)"""
        return _blocks_swig4.pdu_filter_sptr_set_inversion(self, invert)

    def history(self) -> "unsigned int":
        r"""history(pdu_filter_sptr self) -> unsigned int"""
        return _blocks_swig4.pdu_filter_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(pdu_filter_sptr self, int which, int delay)
        declare_sample_delay(pdu_filter_sptr self, unsigned int delay)
        """
        return _blocks_swig4.pdu_filter_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(pdu_filter_sptr self, int which) -> unsigned int"""
        return _blocks_swig4.pdu_filter_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(pdu_filter_sptr self, int multiple)"""
        return _blocks_swig4.pdu_filter_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(pdu_filter_sptr self) -> int"""
        return _blocks_swig4.pdu_filter_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(pdu_filter_sptr self) -> double"""
        return _blocks_swig4.pdu_filter_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(pdu_filter_sptr self) -> uint64_t"""
        return _blocks_swig4.pdu_filter_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(pdu_filter_sptr self) -> uint64_t"""
        return _blocks_swig4.pdu_filter_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(pdu_filter_sptr self) -> bool"""
        return _blocks_swig4.pdu_filter_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(pdu_filter_sptr self) -> bool"""
        return _blocks_swig4.pdu_filter_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(pdu_filter_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig4.pdu_filter_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(pdu_filter_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig4.pdu_filter_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(pdu_filter_sptr self, std::string level)"""
        return _blocks_swig4.pdu_filter_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(pdu_filter_sptr self) -> std::string"""
        return _blocks_swig4.pdu_filter_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(pdu_filter_sptr self) -> int"""
        return _blocks_swig4.pdu_filter_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(pdu_filter_sptr self, int m)"""
        return _blocks_swig4.pdu_filter_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(pdu_filter_sptr self)"""
        return _blocks_swig4.pdu_filter_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(pdu_filter_sptr self) -> bool"""
        return _blocks_swig4.pdu_filter_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(pdu_filter_sptr self, int m)"""
        return _blocks_swig4.pdu_filter_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(pdu_filter_sptr self) -> int"""
        return _blocks_swig4.pdu_filter_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(pdu_filter_sptr self, int i) -> long"""
        return _blocks_swig4.pdu_filter_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(pdu_filter_sptr self, long max_output_buffer)
        set_max_output_buffer(pdu_filter_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig4.pdu_filter_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(pdu_filter_sptr self, int i) -> long"""
        return _blocks_swig4.pdu_filter_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(pdu_filter_sptr self, long min_output_buffer)
        set_min_output_buffer(pdu_filter_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig4.pdu_filter_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(pdu_filter_sptr self) -> float"""
        return _blocks_swig4.pdu_filter_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(pdu_filter_sptr self) -> float"""
        return _blocks_swig4.pdu_filter_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(pdu_filter_sptr self) -> float"""
        return _blocks_swig4.pdu_filter_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(pdu_filter_sptr self) -> float"""
        return _blocks_swig4.pdu_filter_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(pdu_filter_sptr self) -> float"""
        return _blocks_swig4.pdu_filter_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(pdu_filter_sptr self) -> float"""
        return _blocks_swig4.pdu_filter_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(pdu_filter_sptr self) -> float"""
        return _blocks_swig4.pdu_filter_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(pdu_filter_sptr self) -> float"""
        return _blocks_swig4.pdu_filter_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(pdu_filter_sptr self) -> float"""
        return _blocks_swig4.pdu_filter_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(pdu_filter_sptr self) -> float"""
        return _blocks_swig4.pdu_filter_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(pdu_filter_sptr self) -> float"""
        return _blocks_swig4.pdu_filter_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(pdu_filter_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig4.pdu_filter_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(pdu_filter_sptr self)"""
        return _blocks_swig4.pdu_filter_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(pdu_filter_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig4.pdu_filter_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(pdu_filter_sptr self) -> int"""
        return _blocks_swig4.pdu_filter_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(pdu_filter_sptr self) -> int"""
        return _blocks_swig4.pdu_filter_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(pdu_filter_sptr self, int priority) -> int"""
        return _blocks_swig4.pdu_filter_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(pdu_filter_sptr self) -> std::string"""
        return _blocks_swig4.pdu_filter_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(pdu_filter_sptr self) -> std::string"""
        return _blocks_swig4.pdu_filter_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(pdu_filter_sptr self) -> io_signature_sptr"""
        return _blocks_swig4.pdu_filter_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(pdu_filter_sptr self) -> io_signature_sptr"""
        return _blocks_swig4.pdu_filter_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(pdu_filter_sptr self) -> long"""
        return _blocks_swig4.pdu_filter_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(pdu_filter_sptr self) -> basic_block_sptr"""
        return _blocks_swig4.pdu_filter_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(pdu_filter_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig4.pdu_filter_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(pdu_filter_sptr self) -> std::string"""
        return _blocks_swig4.pdu_filter_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(pdu_filter_sptr self, std::string name)"""
        return _blocks_swig4.pdu_filter_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(pdu_filter_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig4.pdu_filter_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(pdu_filter_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig4.pdu_filter_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(pdu_filter_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig4.pdu_filter_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(pdu_filter_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig4.pdu_filter_sptr_message_subscribers(self, which_port)

# Register pdu_filter_sptr in _blocks_swig4:
_blocks_swig4.pdu_filter_sptr_swigregister(pdu_filter_sptr)


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

class pdu_set_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::pdu_set > 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__(pdu_set_sptr self) -> pdu_set_sptr
        __init__(pdu_set_sptr self, pdu_set p) -> pdu_set_sptr
        """
        _blocks_swig4.pdu_set_sptr_swiginit(self, _blocks_swig4.new_pdu_set_sptr(*args))

    def __deref__(self) -> "gr::blocks::pdu_set *":
        r"""__deref__(pdu_set_sptr self) -> pdu_set"""
        return _blocks_swig4.pdu_set_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig4.delete_pdu_set_sptr

    def make(self, k: "swig_pmt_ptr", v: "swig_pmt_ptr") -> "gr::blocks::pdu_set::sptr":
        r"""make(pdu_set_sptr self, swig_pmt_ptr k, swig_pmt_ptr v) -> pdu_set_sptr"""
        return _blocks_swig4.pdu_set_sptr_make(self, k, v)

    def set_key(self, key: "swig_pmt_ptr") -> "void":
        r"""set_key(pdu_set_sptr self, swig_pmt_ptr key)"""
        return _blocks_swig4.pdu_set_sptr_set_key(self, key)

    def set_val(self, val: "swig_pmt_ptr") -> "void":
        r"""set_val(pdu_set_sptr self, swig_pmt_ptr val)"""
        return _blocks_swig4.pdu_set_sptr_set_val(self, val)

    def history(self) -> "unsigned int":
        r"""history(pdu_set_sptr self) -> unsigned int"""
        return _blocks_swig4.pdu_set_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(pdu_set_sptr self, int which, int delay)
        declare_sample_delay(pdu_set_sptr self, unsigned int delay)
        """
        return _blocks_swig4.pdu_set_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(pdu_set_sptr self, int which) -> unsigned int"""
        return _blocks_swig4.pdu_set_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(pdu_set_sptr self, int multiple)"""
        return _blocks_swig4.pdu_set_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(pdu_set_sptr self) -> int"""
        return _blocks_swig4.pdu_set_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(pdu_set_sptr self) -> double"""
        return _blocks_swig4.pdu_set_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(pdu_set_sptr self) -> uint64_t"""
        return _blocks_swig4.pdu_set_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(pdu_set_sptr self) -> uint64_t"""
        return _blocks_swig4.pdu_set_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(pdu_set_sptr self) -> bool"""
        return _blocks_swig4.pdu_set_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(pdu_set_sptr self) -> bool"""
        return _blocks_swig4.pdu_set_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(pdu_set_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig4.pdu_set_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(pdu_set_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig4.pdu_set_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(pdu_set_sptr self, std::string level)"""
        return _blocks_swig4.pdu_set_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(pdu_set_sptr self) -> std::string"""
        return _blocks_swig4.pdu_set_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(pdu_set_sptr self) -> int"""
        return _blocks_swig4.pdu_set_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(pdu_set_sptr self, int m)"""
        return _blocks_swig4.pdu_set_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(pdu_set_sptr self)"""
        return _blocks_swig4.pdu_set_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(pdu_set_sptr self) -> bool"""
        return _blocks_swig4.pdu_set_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(pdu_set_sptr self, int m)"""
        return _blocks_swig4.pdu_set_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(pdu_set_sptr self) -> int"""
        return _blocks_swig4.pdu_set_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(pdu_set_sptr self, int i) -> long"""
        return _blocks_swig4.pdu_set_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(pdu_set_sptr self, long max_output_buffer)
        set_max_output_buffer(pdu_set_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig4.pdu_set_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(pdu_set_sptr self, int i) -> long"""
        return _blocks_swig4.pdu_set_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(pdu_set_sptr self, long min_output_buffer)
        set_min_output_buffer(pdu_set_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig4.pdu_set_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(pdu_set_sptr self) -> float"""
        return _blocks_swig4.pdu_set_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(pdu_set_sptr self) -> float"""
        return _blocks_swig4.pdu_set_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(pdu_set_sptr self) -> float"""
        return _blocks_swig4.pdu_set_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(pdu_set_sptr self) -> float"""
        return _blocks_swig4.pdu_set_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(pdu_set_sptr self) -> float"""
        return _blocks_swig4.pdu_set_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(pdu_set_sptr self) -> float"""
        return _blocks_swig4.pdu_set_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(pdu_set_sptr self) -> float"""
        return _blocks_swig4.pdu_set_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(pdu_set_sptr self) -> float"""
        return _blocks_swig4.pdu_set_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(pdu_set_sptr self) -> float"""
        return _blocks_swig4.pdu_set_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(pdu_set_sptr self) -> float"""
        return _blocks_swig4.pdu_set_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(pdu_set_sptr self) -> float"""
        return _blocks_swig4.pdu_set_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(pdu_set_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig4.pdu_set_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(pdu_set_sptr self)"""
        return _blocks_swig4.pdu_set_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(pdu_set_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig4.pdu_set_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(pdu_set_sptr self) -> int"""
        return _blocks_swig4.pdu_set_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(pdu_set_sptr self) -> int"""
        return _blocks_swig4.pdu_set_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(pdu_set_sptr self, int priority) -> int"""
        return _blocks_swig4.pdu_set_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(pdu_set_sptr self) -> std::string"""
        return _blocks_swig4.pdu_set_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(pdu_set_sptr self) -> std::string"""
        return _blocks_swig4.pdu_set_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(pdu_set_sptr self) -> io_signature_sptr"""
        return _blocks_swig4.pdu_set_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(pdu_set_sptr self) -> io_signature_sptr"""
        return _blocks_swig4.pdu_set_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(pdu_set_sptr self) -> long"""
        return _blocks_swig4.pdu_set_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(pdu_set_sptr self) -> basic_block_sptr"""
        return _blocks_swig4.pdu_set_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(pdu_set_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig4.pdu_set_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(pdu_set_sptr self) -> std::string"""
        return _blocks_swig4.pdu_set_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(pdu_set_sptr self, std::string name)"""
        return _blocks_swig4.pdu_set_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(pdu_set_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig4.pdu_set_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(pdu_set_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig4.pdu_set_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(pdu_set_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig4.pdu_set_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(pdu_set_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig4.pdu_set_sptr_message_subscribers(self, which_port)

# Register pdu_set_sptr in _blocks_swig4:
_blocks_swig4.pdu_set_sptr_swigregister(pdu_set_sptr)


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

class pdu_remove_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::pdu_remove > 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__(pdu_remove_sptr self) -> pdu_remove_sptr
        __init__(pdu_remove_sptr self, pdu_remove p) -> pdu_remove_sptr
        """
        _blocks_swig4.pdu_remove_sptr_swiginit(self, _blocks_swig4.new_pdu_remove_sptr(*args))

    def __deref__(self) -> "gr::blocks::pdu_remove *":
        r"""__deref__(pdu_remove_sptr self) -> pdu_remove"""
        return _blocks_swig4.pdu_remove_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig4.delete_pdu_remove_sptr

    def make(self, k: "swig_pmt_ptr") -> "gr::blocks::pdu_remove::sptr":
        r"""make(pdu_remove_sptr self, swig_pmt_ptr k) -> pdu_remove_sptr"""
        return _blocks_swig4.pdu_remove_sptr_make(self, k)

    def set_key(self, key: "swig_pmt_ptr") -> "void":
        r"""set_key(pdu_remove_sptr self, swig_pmt_ptr key)"""
        return _blocks_swig4.pdu_remove_sptr_set_key(self, key)

    def history(self) -> "unsigned int":
        r"""history(pdu_remove_sptr self) -> unsigned int"""
        return _blocks_swig4.pdu_remove_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(pdu_remove_sptr self, int which, int delay)
        declare_sample_delay(pdu_remove_sptr self, unsigned int delay)
        """
        return _blocks_swig4.pdu_remove_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(pdu_remove_sptr self, int which) -> unsigned int"""
        return _blocks_swig4.pdu_remove_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(pdu_remove_sptr self, int multiple)"""
        return _blocks_swig4.pdu_remove_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(pdu_remove_sptr self) -> int"""
        return _blocks_swig4.pdu_remove_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(pdu_remove_sptr self) -> double"""
        return _blocks_swig4.pdu_remove_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(pdu_remove_sptr self) -> uint64_t"""
        return _blocks_swig4.pdu_remove_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(pdu_remove_sptr self) -> uint64_t"""
        return _blocks_swig4.pdu_remove_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(pdu_remove_sptr self) -> bool"""
        return _blocks_swig4.pdu_remove_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(pdu_remove_sptr self) -> bool"""
        return _blocks_swig4.pdu_remove_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(pdu_remove_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig4.pdu_remove_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(pdu_remove_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig4.pdu_remove_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(pdu_remove_sptr self, std::string level)"""
        return _blocks_swig4.pdu_remove_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(pdu_remove_sptr self) -> std::string"""
        return _blocks_swig4.pdu_remove_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(pdu_remove_sptr self) -> int"""
        return _blocks_swig4.pdu_remove_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(pdu_remove_sptr self, int m)"""
        return _blocks_swig4.pdu_remove_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(pdu_remove_sptr self)"""
        return _blocks_swig4.pdu_remove_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(pdu_remove_sptr self) -> bool"""
        return _blocks_swig4.pdu_remove_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(pdu_remove_sptr self, int m)"""
        return _blocks_swig4.pdu_remove_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(pdu_remove_sptr self) -> int"""
        return _blocks_swig4.pdu_remove_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(pdu_remove_sptr self, int i) -> long"""
        return _blocks_swig4.pdu_remove_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(pdu_remove_sptr self, long max_output_buffer)
        set_max_output_buffer(pdu_remove_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig4.pdu_remove_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(pdu_remove_sptr self, int i) -> long"""
        return _blocks_swig4.pdu_remove_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(pdu_remove_sptr self, long min_output_buffer)
        set_min_output_buffer(pdu_remove_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig4.pdu_remove_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(pdu_remove_sptr self) -> float"""
        return _blocks_swig4.pdu_remove_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(pdu_remove_sptr self) -> float"""
        return _blocks_swig4.pdu_remove_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(pdu_remove_sptr self) -> float"""
        return _blocks_swig4.pdu_remove_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(pdu_remove_sptr self) -> float"""
        return _blocks_swig4.pdu_remove_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(pdu_remove_sptr self) -> float"""
        return _blocks_swig4.pdu_remove_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(pdu_remove_sptr self) -> float"""
        return _blocks_swig4.pdu_remove_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(pdu_remove_sptr self) -> float"""
        return _blocks_swig4.pdu_remove_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(pdu_remove_sptr self) -> float"""
        return _blocks_swig4.pdu_remove_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(pdu_remove_sptr self) -> float"""
        return _blocks_swig4.pdu_remove_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(pdu_remove_sptr self) -> float"""
        return _blocks_swig4.pdu_remove_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(pdu_remove_sptr self) -> float"""
        return _blocks_swig4.pdu_remove_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(pdu_remove_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig4.pdu_remove_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(pdu_remove_sptr self)"""
        return _blocks_swig4.pdu_remove_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(pdu_remove_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig4.pdu_remove_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(pdu_remove_sptr self) -> int"""
        return _blocks_swig4.pdu_remove_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(pdu_remove_sptr self) -> int"""
        return _blocks_swig4.pdu_remove_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(pdu_remove_sptr self, int priority) -> int"""
        return _blocks_swig4.pdu_remove_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(pdu_remove_sptr self) -> std::string"""
        return _blocks_swig4.pdu_remove_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(pdu_remove_sptr self) -> std::string"""
        return _blocks_swig4.pdu_remove_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(pdu_remove_sptr self) -> io_signature_sptr"""
        return _blocks_swig4.pdu_remove_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(pdu_remove_sptr self) -> io_signature_sptr"""
        return _blocks_swig4.pdu_remove_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(pdu_remove_sptr self) -> long"""
        return _blocks_swig4.pdu_remove_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(pdu_remove_sptr self) -> basic_block_sptr"""
        return _blocks_swig4.pdu_remove_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(pdu_remove_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig4.pdu_remove_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(pdu_remove_sptr self) -> std::string"""
        return _blocks_swig4.pdu_remove_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(pdu_remove_sptr self, std::string name)"""
        return _blocks_swig4.pdu_remove_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(pdu_remove_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig4.pdu_remove_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(pdu_remove_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig4.pdu_remove_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(pdu_remove_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig4.pdu_remove_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(pdu_remove_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig4.pdu_remove_sptr_message_subscribers(self, which_port)

# Register pdu_remove_sptr in _blocks_swig4:
_blocks_swig4.pdu_remove_sptr_swigregister(pdu_remove_sptr)


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

class pdu_to_tagged_stream_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::pdu_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__(pdu_to_tagged_stream_sptr self) -> pdu_to_tagged_stream_sptr
        __init__(pdu_to_tagged_stream_sptr self, pdu_to_tagged_stream p) -> pdu_to_tagged_stream_sptr
        """
        _blocks_swig4.pdu_to_tagged_stream_sptr_swiginit(self, _blocks_swig4.new_pdu_to_tagged_stream_sptr(*args))

    def __deref__(self) -> "gr::blocks::pdu_to_tagged_stream *":
        r"""__deref__(pdu_to_tagged_stream_sptr self) -> pdu_to_tagged_stream"""
        return _blocks_swig4.pdu_to_tagged_stream_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig4.delete_pdu_to_tagged_stream_sptr

    def make(self, *args, **kwargs) -> "gr::blocks::pdu_to_tagged_stream::sptr":
        r"""make(pdu_to_tagged_stream_sptr self, gr::blocks::pdu::vector_type type, std::string const & lengthtagname="packet_len") -> pdu_to_tagged_stream_sptr"""
        return _blocks_swig4.pdu_to_tagged_stream_sptr_make(self, *args, **kwargs)

    def history(self) -> "unsigned int":
        r"""history(pdu_to_tagged_stream_sptr self) -> unsigned int"""
        return _blocks_swig4.pdu_to_tagged_stream_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(pdu_to_tagged_stream_sptr self, int which, int delay)
        declare_sample_delay(pdu_to_tagged_stream_sptr self, unsigned int delay)
        """
        return _blocks_swig4.pdu_to_tagged_stream_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(pdu_to_tagged_stream_sptr self, int which) -> unsigned int"""
        return _blocks_swig4.pdu_to_tagged_stream_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(pdu_to_tagged_stream_sptr self, int multiple)"""
        return _blocks_swig4.pdu_to_tagged_stream_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(pdu_to_tagged_stream_sptr self) -> int"""
        return _blocks_swig4.pdu_to_tagged_stream_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(pdu_to_tagged_stream_sptr self) -> double"""
        return _blocks_swig4.pdu_to_tagged_stream_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(pdu_to_tagged_stream_sptr self) -> uint64_t"""
        return _blocks_swig4.pdu_to_tagged_stream_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(pdu_to_tagged_stream_sptr self) -> uint64_t"""
        return _blocks_swig4.pdu_to_tagged_stream_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(pdu_to_tagged_stream_sptr self) -> bool"""
        return _blocks_swig4.pdu_to_tagged_stream_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(pdu_to_tagged_stream_sptr self) -> bool"""
        return _blocks_swig4.pdu_to_tagged_stream_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(pdu_to_tagged_stream_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig4.pdu_to_tagged_stream_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(pdu_to_tagged_stream_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig4.pdu_to_tagged_stream_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(pdu_to_tagged_stream_sptr self, std::string level)"""
        return _blocks_swig4.pdu_to_tagged_stream_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(pdu_to_tagged_stream_sptr self) -> std::string"""
        return _blocks_swig4.pdu_to_tagged_stream_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(pdu_to_tagged_stream_sptr self) -> int"""
        return _blocks_swig4.pdu_to_tagged_stream_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(pdu_to_tagged_stream_sptr self, int m)"""
        return _blocks_swig4.pdu_to_tagged_stream_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(pdu_to_tagged_stream_sptr self)"""
        return _blocks_swig4.pdu_to_tagged_stream_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(pdu_to_tagged_stream_sptr self) -> bool"""
        return _blocks_swig4.pdu_to_tagged_stream_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(pdu_to_tagged_stream_sptr self, int m)"""
        return _blocks_swig4.pdu_to_tagged_stream_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(pdu_to_tagged_stream_sptr self) -> int"""
        return _blocks_swig4.pdu_to_tagged_stream_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(pdu_to_tagged_stream_sptr self, int i) -> long"""
        return _blocks_swig4.pdu_to_tagged_stream_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(pdu_to_tagged_stream_sptr self, long max_output_buffer)
        set_max_output_buffer(pdu_to_tagged_stream_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig4.pdu_to_tagged_stream_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(pdu_to_tagged_stream_sptr self, int i) -> long"""
        return _blocks_swig4.pdu_to_tagged_stream_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(pdu_to_tagged_stream_sptr self, long min_output_buffer)
        set_min_output_buffer(pdu_to_tagged_stream_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig4.pdu_to_tagged_stream_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(pdu_to_tagged_stream_sptr self) -> float"""
        return _blocks_swig4.pdu_to_tagged_stream_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(pdu_to_tagged_stream_sptr self) -> float"""
        return _blocks_swig4.pdu_to_tagged_stream_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(pdu_to_tagged_stream_sptr self) -> float"""
        return _blocks_swig4.pdu_to_tagged_stream_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(pdu_to_tagged_stream_sptr self) -> float"""
        return _blocks_swig4.pdu_to_tagged_stream_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(pdu_to_tagged_stream_sptr self) -> float"""
        return _blocks_swig4.pdu_to_tagged_stream_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(pdu_to_tagged_stream_sptr self) -> float"""
        return _blocks_swig4.pdu_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(pdu_to_tagged_stream_sptr self, int which) -> float
        pc_input_buffers_full(pdu_to_tagged_stream_sptr self) -> pmt_vector_float
        """
        return _blocks_swig4.pdu_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(pdu_to_tagged_stream_sptr self, int which) -> float
        pc_input_buffers_full_avg(pdu_to_tagged_stream_sptr self) -> pmt_vector_float
        """
        return _blocks_swig4.pdu_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(pdu_to_tagged_stream_sptr self, int which) -> float
        pc_input_buffers_full_var(pdu_to_tagged_stream_sptr self) -> pmt_vector_float
        """
        return _blocks_swig4.pdu_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(pdu_to_tagged_stream_sptr self, int which) -> float
        pc_output_buffers_full(pdu_to_tagged_stream_sptr self) -> pmt_vector_float
        """
        return _blocks_swig4.pdu_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(pdu_to_tagged_stream_sptr self, int which) -> float
        pc_output_buffers_full_avg(pdu_to_tagged_stream_sptr self) -> pmt_vector_float
        """
        return _blocks_swig4.pdu_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(pdu_to_tagged_stream_sptr self, int which) -> float
        pc_output_buffers_full_var(pdu_to_tagged_stream_sptr self) -> pmt_vector_float
        """
        return _blocks_swig4.pdu_to_tagged_stream_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(pdu_to_tagged_stream_sptr self) -> float"""
        return _blocks_swig4.pdu_to_tagged_stream_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(pdu_to_tagged_stream_sptr self) -> float"""
        return _blocks_swig4.pdu_to_tagged_stream_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(pdu_to_tagged_stream_sptr self) -> float"""
        return _blocks_swig4.pdu_to_tagged_stream_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(pdu_to_tagged_stream_sptr self) -> float"""
        return _blocks_swig4.pdu_to_tagged_stream_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(pdu_to_tagged_stream_sptr self) -> float"""
        return _blocks_swig4.pdu_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(pdu_to_tagged_stream_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig4.pdu_to_tagged_stream_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(pdu_to_tagged_stream_sptr self)"""
        return _blocks_swig4.pdu_to_tagged_stream_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(pdu_to_tagged_stream_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig4.pdu_to_tagged_stream_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(pdu_to_tagged_stream_sptr self) -> int"""
        return _blocks_swig4.pdu_to_tagged_stream_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(pdu_to_tagged_stream_sptr self) -> int"""
        return _blocks_swig4.pdu_to_tagged_stream_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(pdu_to_tagged_stream_sptr self, int priority) -> int"""
        return _blocks_swig4.pdu_to_tagged_stream_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(pdu_to_tagged_stream_sptr self) -> std::string"""
        return _blocks_swig4.pdu_to_tagged_stream_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(pdu_to_tagged_stream_sptr self) -> std::string"""
        return _blocks_swig4.pdu_to_tagged_stream_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(pdu_to_tagged_stream_sptr self) -> io_signature_sptr"""
        return _blocks_swig4.pdu_to_tagged_stream_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(pdu_to_tagged_stream_sptr self) -> io_signature_sptr"""
        return _blocks_swig4.pdu_to_tagged_stream_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(pdu_to_tagged_stream_sptr self) -> long"""
        return _blocks_swig4.pdu_to_tagged_stream_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(pdu_to_tagged_stream_sptr self) -> basic_block_sptr"""
        return _blocks_swig4.pdu_to_tagged_stream_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(pdu_to_tagged_stream_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig4.pdu_to_tagged_stream_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(pdu_to_tagged_stream_sptr self) -> std::string"""
        return _blocks_swig4.pdu_to_tagged_stream_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(pdu_to_tagged_stream_sptr self, std::string name)"""
        return _blocks_swig4.pdu_to_tagged_stream_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(pdu_to_tagged_stream_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig4.pdu_to_tagged_stream_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(pdu_to_tagged_stream_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig4.pdu_to_tagged_stream_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(pdu_to_tagged_stream_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig4.pdu_to_tagged_stream_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(pdu_to_tagged_stream_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig4.pdu_to_tagged_stream_sptr_message_subscribers(self, which_port)

# Register pdu_to_tagged_stream_sptr in _blocks_swig4:
_blocks_swig4.pdu_to_tagged_stream_sptr_swigregister(pdu_to_tagged_stream_sptr)


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

class probe_rate_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::probe_rate > 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__(probe_rate_sptr self) -> probe_rate_sptr
        __init__(probe_rate_sptr self, probe_rate p) -> probe_rate_sptr
        """
        _blocks_swig4.probe_rate_sptr_swiginit(self, _blocks_swig4.new_probe_rate_sptr(*args))

    def __deref__(self) -> "gr::blocks::probe_rate *":
        r"""__deref__(probe_rate_sptr self) -> probe_rate"""
        return _blocks_swig4.probe_rate_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig4.delete_probe_rate_sptr

    def make(self, itemsize: "size_t", update_rate_ms: "double"=500.0, alpha: "double"=0.0001) -> "gr::blocks::probe_rate::sptr":
        r"""make(probe_rate_sptr self, size_t itemsize, double update_rate_ms=500.0, double alpha=0.0001) -> probe_rate_sptr"""
        return _blocks_swig4.probe_rate_sptr_make(self, itemsize, update_rate_ms, alpha)

    def set_alpha(self, alpha: "double") -> "void":
        r"""set_alpha(probe_rate_sptr self, double alpha)"""
        return _blocks_swig4.probe_rate_sptr_set_alpha(self, alpha)

    def rate(self) -> "double":
        r"""rate(probe_rate_sptr self) -> double"""
        return _blocks_swig4.probe_rate_sptr_rate(self)

    def start(self) -> "bool":
        r"""start(probe_rate_sptr self) -> bool"""
        return _blocks_swig4.probe_rate_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(probe_rate_sptr self) -> bool"""
        return _blocks_swig4.probe_rate_sptr_stop(self)

    def history(self) -> "unsigned int":
        r"""history(probe_rate_sptr self) -> unsigned int"""
        return _blocks_swig4.probe_rate_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(probe_rate_sptr self, int which, int delay)
        declare_sample_delay(probe_rate_sptr self, unsigned int delay)
        """
        return _blocks_swig4.probe_rate_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(probe_rate_sptr self, int which) -> unsigned int"""
        return _blocks_swig4.probe_rate_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(probe_rate_sptr self, int multiple)"""
        return _blocks_swig4.probe_rate_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(probe_rate_sptr self) -> int"""
        return _blocks_swig4.probe_rate_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(probe_rate_sptr self) -> double"""
        return _blocks_swig4.probe_rate_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(probe_rate_sptr self) -> uint64_t"""
        return _blocks_swig4.probe_rate_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(probe_rate_sptr self) -> uint64_t"""
        return _blocks_swig4.probe_rate_sptr_relative_rate_d(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(probe_rate_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig4.probe_rate_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(probe_rate_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig4.probe_rate_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(probe_rate_sptr self, std::string level)"""
        return _blocks_swig4.probe_rate_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(probe_rate_sptr self) -> std::string"""
        return _blocks_swig4.probe_rate_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(probe_rate_sptr self) -> int"""
        return _blocks_swig4.probe_rate_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(probe_rate_sptr self, int m)"""
        return _blocks_swig4.probe_rate_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(probe_rate_sptr self)"""
        return _blocks_swig4.probe_rate_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(probe_rate_sptr self) -> bool"""
        return _blocks_swig4.probe_rate_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(probe_rate_sptr self, int m)"""
        return _blocks_swig4.probe_rate_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(probe_rate_sptr self) -> int"""
        return _blocks_swig4.probe_rate_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(probe_rate_sptr self, int i) -> long"""
        return _blocks_swig4.probe_rate_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(probe_rate_sptr self, long max_output_buffer)
        set_max_output_buffer(probe_rate_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig4.probe_rate_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(probe_rate_sptr self, int i) -> long"""
        return _blocks_swig4.probe_rate_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(probe_rate_sptr self, long min_output_buffer)
        set_min_output_buffer(probe_rate_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig4.probe_rate_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(probe_rate_sptr self) -> float"""
        return _blocks_swig4.probe_rate_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(probe_rate_sptr self) -> float"""
        return _blocks_swig4.probe_rate_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(probe_rate_sptr self) -> float"""
        return _blocks_swig4.probe_rate_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(probe_rate_sptr self) -> float"""
        return _blocks_swig4.probe_rate_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(probe_rate_sptr self) -> float"""
        return _blocks_swig4.probe_rate_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(probe_rate_sptr self) -> float"""
        return _blocks_swig4.probe_rate_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(probe_rate_sptr self) -> float"""
        return _blocks_swig4.probe_rate_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(probe_rate_sptr self) -> float"""
        return _blocks_swig4.probe_rate_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(probe_rate_sptr self) -> float"""
        return _blocks_swig4.probe_rate_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(probe_rate_sptr self) -> float"""
        return _blocks_swig4.probe_rate_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(probe_rate_sptr self) -> float"""
        return _blocks_swig4.probe_rate_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(probe_rate_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig4.probe_rate_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(probe_rate_sptr self)"""
        return _blocks_swig4.probe_rate_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(probe_rate_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig4.probe_rate_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(probe_rate_sptr self) -> int"""
        return _blocks_swig4.probe_rate_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(probe_rate_sptr self) -> int"""
        return _blocks_swig4.probe_rate_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(probe_rate_sptr self, int priority) -> int"""
        return _blocks_swig4.probe_rate_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(probe_rate_sptr self) -> std::string"""
        return _blocks_swig4.probe_rate_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(probe_rate_sptr self) -> std::string"""
        return _blocks_swig4.probe_rate_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(probe_rate_sptr self) -> io_signature_sptr"""
        return _blocks_swig4.probe_rate_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(probe_rate_sptr self) -> io_signature_sptr"""
        return _blocks_swig4.probe_rate_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(probe_rate_sptr self) -> long"""
        return _blocks_swig4.probe_rate_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(probe_rate_sptr self) -> basic_block_sptr"""
        return _blocks_swig4.probe_rate_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(probe_rate_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig4.probe_rate_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(probe_rate_sptr self) -> std::string"""
        return _blocks_swig4.probe_rate_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(probe_rate_sptr self, std::string name)"""
        return _blocks_swig4.probe_rate_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(probe_rate_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig4.probe_rate_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(probe_rate_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig4.probe_rate_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(probe_rate_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig4.probe_rate_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(probe_rate_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig4.probe_rate_sptr_message_subscribers(self, which_port)

# Register probe_rate_sptr in _blocks_swig4:
_blocks_swig4.probe_rate_sptr_swigregister(probe_rate_sptr)


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

class probe_signal_b(object):
    r"""Proxy of C++ gr::blocks::probe_signal< 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

    @staticmethod
    def make() -> "gr::blocks::probe_signal< unsigned char >::sptr":
        r"""make() -> probe_signal_b_sptr"""
        return _blocks_swig4.probe_signal_b_make()

    def level(self) -> "std::uint8_t":
        r"""level(probe_signal_b self) -> std::uint8_t"""
        return _blocks_swig4.probe_signal_b_level(self)
    __swig_destroy__ = _blocks_swig4.delete_probe_signal_b

# Register probe_signal_b in _blocks_swig4:
_blocks_swig4.probe_signal_b_swigregister(probe_signal_b)

def probe_signal_b_make() -> "gr::blocks::probe_signal< unsigned char >::sptr":
    r"""probe_signal_b_make() -> probe_signal_b_sptr"""
    return _blocks_swig4.probe_signal_b_make()

class probe_signal_b_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::probe_signal< 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__(probe_signal_b_sptr self) -> probe_signal_b_sptr
        __init__(probe_signal_b_sptr self, probe_signal_b p) -> probe_signal_b_sptr
        """
        _blocks_swig4.probe_signal_b_sptr_swiginit(self, _blocks_swig4.new_probe_signal_b_sptr(*args))

    def __deref__(self) -> "gr::blocks::probe_signal< std::uint8_t > *":
        r"""__deref__(probe_signal_b_sptr self) -> probe_signal_b"""
        return _blocks_swig4.probe_signal_b_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig4.delete_probe_signal_b_sptr

    def make(self) -> "gr::blocks::probe_signal< unsigned char >::sptr":
        r"""make(probe_signal_b_sptr self) -> probe_signal_b_sptr"""
        return _blocks_swig4.probe_signal_b_sptr_make(self)

    def level(self) -> "std::uint8_t":
        r"""level(probe_signal_b_sptr self) -> std::uint8_t"""
        return _blocks_swig4.probe_signal_b_sptr_level(self)

    def history(self) -> "unsigned int":
        r"""history(probe_signal_b_sptr self) -> unsigned int"""
        return _blocks_swig4.probe_signal_b_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(probe_signal_b_sptr self, int which, int delay)
        declare_sample_delay(probe_signal_b_sptr self, unsigned int delay)
        """
        return _blocks_swig4.probe_signal_b_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(probe_signal_b_sptr self, int which) -> unsigned int"""
        return _blocks_swig4.probe_signal_b_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(probe_signal_b_sptr self, int multiple)"""
        return _blocks_swig4.probe_signal_b_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(probe_signal_b_sptr self) -> int"""
        return _blocks_swig4.probe_signal_b_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(probe_signal_b_sptr self) -> double"""
        return _blocks_swig4.probe_signal_b_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(probe_signal_b_sptr self) -> uint64_t"""
        return _blocks_swig4.probe_signal_b_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(probe_signal_b_sptr self) -> uint64_t"""
        return _blocks_swig4.probe_signal_b_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(probe_signal_b_sptr self) -> bool"""
        return _blocks_swig4.probe_signal_b_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(probe_signal_b_sptr self) -> bool"""
        return _blocks_swig4.probe_signal_b_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(probe_signal_b_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig4.probe_signal_b_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(probe_signal_b_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig4.probe_signal_b_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(probe_signal_b_sptr self, std::string level)"""
        return _blocks_swig4.probe_signal_b_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(probe_signal_b_sptr self) -> std::string"""
        return _blocks_swig4.probe_signal_b_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(probe_signal_b_sptr self) -> int"""
        return _blocks_swig4.probe_signal_b_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(probe_signal_b_sptr self, int m)"""
        return _blocks_swig4.probe_signal_b_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(probe_signal_b_sptr self)"""
        return _blocks_swig4.probe_signal_b_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(probe_signal_b_sptr self) -> bool"""
        return _blocks_swig4.probe_signal_b_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(probe_signal_b_sptr self, int m)"""
        return _blocks_swig4.probe_signal_b_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(probe_signal_b_sptr self) -> int"""
        return _blocks_swig4.probe_signal_b_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(probe_signal_b_sptr self, int i) -> long"""
        return _blocks_swig4.probe_signal_b_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(probe_signal_b_sptr self, long max_output_buffer)
        set_max_output_buffer(probe_signal_b_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig4.probe_signal_b_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(probe_signal_b_sptr self, int i) -> long"""
        return _blocks_swig4.probe_signal_b_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(probe_signal_b_sptr self, long min_output_buffer)
        set_min_output_buffer(probe_signal_b_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig4.probe_signal_b_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(probe_signal_b_sptr self) -> float"""
        return _blocks_swig4.probe_signal_b_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(probe_signal_b_sptr self) -> float"""
        return _blocks_swig4.probe_signal_b_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(probe_signal_b_sptr self) -> float"""
        return _blocks_swig4.probe_signal_b_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(probe_signal_b_sptr self) -> float"""
        return _blocks_swig4.probe_signal_b_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(probe_signal_b_sptr self) -> float"""
        return _blocks_swig4.probe_signal_b_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(probe_signal_b_sptr self) -> float"""
        return _blocks_swig4.probe_signal_b_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(probe_signal_b_sptr self) -> float"""
        return _blocks_swig4.probe_signal_b_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(probe_signal_b_sptr self) -> float"""
        return _blocks_swig4.probe_signal_b_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(probe_signal_b_sptr self) -> float"""
        return _blocks_swig4.probe_signal_b_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(probe_signal_b_sptr self) -> float"""
        return _blocks_swig4.probe_signal_b_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(probe_signal_b_sptr self) -> float"""
        return _blocks_swig4.probe_signal_b_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(probe_signal_b_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig4.probe_signal_b_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(probe_signal_b_sptr self)"""
        return _blocks_swig4.probe_signal_b_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(probe_signal_b_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig4.probe_signal_b_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(probe_signal_b_sptr self) -> int"""
        return _blocks_swig4.probe_signal_b_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(probe_signal_b_sptr self) -> int"""
        return _blocks_swig4.probe_signal_b_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(probe_signal_b_sptr self, int priority) -> int"""
        return _blocks_swig4.probe_signal_b_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(probe_signal_b_sptr self) -> std::string"""
        return _blocks_swig4.probe_signal_b_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(probe_signal_b_sptr self) -> std::string"""
        return _blocks_swig4.probe_signal_b_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(probe_signal_b_sptr self) -> io_signature_sptr"""
        return _blocks_swig4.probe_signal_b_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(probe_signal_b_sptr self) -> io_signature_sptr"""
        return _blocks_swig4.probe_signal_b_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(probe_signal_b_sptr self) -> long"""
        return _blocks_swig4.probe_signal_b_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(probe_signal_b_sptr self) -> basic_block_sptr"""
        return _blocks_swig4.probe_signal_b_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(probe_signal_b_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig4.probe_signal_b_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(probe_signal_b_sptr self) -> std::string"""
        return _blocks_swig4.probe_signal_b_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(probe_signal_b_sptr self, std::string name)"""
        return _blocks_swig4.probe_signal_b_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(probe_signal_b_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig4.probe_signal_b_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(probe_signal_b_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig4.probe_signal_b_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(probe_signal_b_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig4.probe_signal_b_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(probe_signal_b_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig4.probe_signal_b_sptr_message_subscribers(self, which_port)

# Register probe_signal_b_sptr in _blocks_swig4:
_blocks_swig4.probe_signal_b_sptr_swigregister(probe_signal_b_sptr)


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

class probe_signal_s(object):
    r"""Proxy of C++ gr::blocks::probe_signal< 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

    @staticmethod
    def make() -> "gr::blocks::probe_signal< short >::sptr":
        r"""make() -> probe_signal_s_sptr"""
        return _blocks_swig4.probe_signal_s_make()

    def level(self) -> "std::int16_t":
        r"""level(probe_signal_s self) -> std::int16_t"""
        return _blocks_swig4.probe_signal_s_level(self)
    __swig_destroy__ = _blocks_swig4.delete_probe_signal_s

# Register probe_signal_s in _blocks_swig4:
_blocks_swig4.probe_signal_s_swigregister(probe_signal_s)

def probe_signal_s_make() -> "gr::blocks::probe_signal< short >::sptr":
    r"""probe_signal_s_make() -> probe_signal_s_sptr"""
    return _blocks_swig4.probe_signal_s_make()

class probe_signal_s_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::probe_signal< 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__(probe_signal_s_sptr self) -> probe_signal_s_sptr
        __init__(probe_signal_s_sptr self, probe_signal_s p) -> probe_signal_s_sptr
        """
        _blocks_swig4.probe_signal_s_sptr_swiginit(self, _blocks_swig4.new_probe_signal_s_sptr(*args))

    def __deref__(self) -> "gr::blocks::probe_signal< std::int16_t > *":
        r"""__deref__(probe_signal_s_sptr self) -> probe_signal_s"""
        return _blocks_swig4.probe_signal_s_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig4.delete_probe_signal_s_sptr

    def make(self) -> "gr::blocks::probe_signal< short >::sptr":
        r"""make(probe_signal_s_sptr self) -> probe_signal_s_sptr"""
        return _blocks_swig4.probe_signal_s_sptr_make(self)

    def level(self) -> "std::int16_t":
        r"""level(probe_signal_s_sptr self) -> std::int16_t"""
        return _blocks_swig4.probe_signal_s_sptr_level(self)

    def history(self) -> "unsigned int":
        r"""history(probe_signal_s_sptr self) -> unsigned int"""
        return _blocks_swig4.probe_signal_s_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(probe_signal_s_sptr self, int which, int delay)
        declare_sample_delay(probe_signal_s_sptr self, unsigned int delay)
        """
        return _blocks_swig4.probe_signal_s_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(probe_signal_s_sptr self, int which) -> unsigned int"""
        return _blocks_swig4.probe_signal_s_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(probe_signal_s_sptr self, int multiple)"""
        return _blocks_swig4.probe_signal_s_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(probe_signal_s_sptr self) -> int"""
        return _blocks_swig4.probe_signal_s_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(probe_signal_s_sptr self) -> double"""
        return _blocks_swig4.probe_signal_s_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(probe_signal_s_sptr self) -> uint64_t"""
        return _blocks_swig4.probe_signal_s_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(probe_signal_s_sptr self) -> uint64_t"""
        return _blocks_swig4.probe_signal_s_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(probe_signal_s_sptr self) -> bool"""
        return _blocks_swig4.probe_signal_s_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(probe_signal_s_sptr self) -> bool"""
        return _blocks_swig4.probe_signal_s_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(probe_signal_s_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig4.probe_signal_s_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(probe_signal_s_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig4.probe_signal_s_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(probe_signal_s_sptr self, std::string level)"""
        return _blocks_swig4.probe_signal_s_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(probe_signal_s_sptr self) -> std::string"""
        return _blocks_swig4.probe_signal_s_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(probe_signal_s_sptr self) -> int"""
        return _blocks_swig4.probe_signal_s_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(probe_signal_s_sptr self, int m)"""
        return _blocks_swig4.probe_signal_s_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(probe_signal_s_sptr self)"""
        return _blocks_swig4.probe_signal_s_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(probe_signal_s_sptr self) -> bool"""
        return _blocks_swig4.probe_signal_s_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(probe_signal_s_sptr self, int m)"""
        return _blocks_swig4.probe_signal_s_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(probe_signal_s_sptr self) -> int"""
        return _blocks_swig4.probe_signal_s_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(probe_signal_s_sptr self, int i) -> long"""
        return _blocks_swig4.probe_signal_s_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(probe_signal_s_sptr self, long max_output_buffer)
        set_max_output_buffer(probe_signal_s_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig4.probe_signal_s_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(probe_signal_s_sptr self, int i) -> long"""
        return _blocks_swig4.probe_signal_s_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(probe_signal_s_sptr self, long min_output_buffer)
        set_min_output_buffer(probe_signal_s_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig4.probe_signal_s_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(probe_signal_s_sptr self) -> float"""
        return _blocks_swig4.probe_signal_s_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(probe_signal_s_sptr self) -> float"""
        return _blocks_swig4.probe_signal_s_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(probe_signal_s_sptr self) -> float"""
        return _blocks_swig4.probe_signal_s_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(probe_signal_s_sptr self) -> float"""
        return _blocks_swig4.probe_signal_s_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(probe_signal_s_sptr self) -> float"""
        return _blocks_swig4.probe_signal_s_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(probe_signal_s_sptr self) -> float"""
        return _blocks_swig4.probe_signal_s_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(probe_signal_s_sptr self) -> float"""
        return _blocks_swig4.probe_signal_s_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(probe_signal_s_sptr self) -> float"""
        return _blocks_swig4.probe_signal_s_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(probe_signal_s_sptr self) -> float"""
        return _blocks_swig4.probe_signal_s_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(probe_signal_s_sptr self) -> float"""
        return _blocks_swig4.probe_signal_s_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(probe_signal_s_sptr self) -> float"""
        return _blocks_swig4.probe_signal_s_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(probe_signal_s_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig4.probe_signal_s_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(probe_signal_s_sptr self)"""
        return _blocks_swig4.probe_signal_s_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(probe_signal_s_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig4.probe_signal_s_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(probe_signal_s_sptr self) -> int"""
        return _blocks_swig4.probe_signal_s_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(probe_signal_s_sptr self) -> int"""
        return _blocks_swig4.probe_signal_s_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(probe_signal_s_sptr self, int priority) -> int"""
        return _blocks_swig4.probe_signal_s_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(probe_signal_s_sptr self) -> std::string"""
        return _blocks_swig4.probe_signal_s_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(probe_signal_s_sptr self) -> std::string"""
        return _blocks_swig4.probe_signal_s_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(probe_signal_s_sptr self) -> io_signature_sptr"""
        return _blocks_swig4.probe_signal_s_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(probe_signal_s_sptr self) -> io_signature_sptr"""
        return _blocks_swig4.probe_signal_s_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(probe_signal_s_sptr self) -> long"""
        return _blocks_swig4.probe_signal_s_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(probe_signal_s_sptr self) -> basic_block_sptr"""
        return _blocks_swig4.probe_signal_s_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(probe_signal_s_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig4.probe_signal_s_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(probe_signal_s_sptr self) -> std::string"""
        return _blocks_swig4.probe_signal_s_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(probe_signal_s_sptr self, std::string name)"""
        return _blocks_swig4.probe_signal_s_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(probe_signal_s_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig4.probe_signal_s_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(probe_signal_s_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig4.probe_signal_s_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(probe_signal_s_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig4.probe_signal_s_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(probe_signal_s_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig4.probe_signal_s_sptr_message_subscribers(self, which_port)

# Register probe_signal_s_sptr in _blocks_swig4:
_blocks_swig4.probe_signal_s_sptr_swigregister(probe_signal_s_sptr)


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

class probe_signal_i(object):
    r"""Proxy of C++ gr::blocks::probe_signal< 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

    @staticmethod
    def make() -> "gr::blocks::probe_signal< int >::sptr":
        r"""make() -> probe_signal_i_sptr"""
        return _blocks_swig4.probe_signal_i_make()

    def level(self) -> "std::int32_t":
        r"""level(probe_signal_i self) -> std::int32_t"""
        return _blocks_swig4.probe_signal_i_level(self)
    __swig_destroy__ = _blocks_swig4.delete_probe_signal_i

# Register probe_signal_i in _blocks_swig4:
_blocks_swig4.probe_signal_i_swigregister(probe_signal_i)

def probe_signal_i_make() -> "gr::blocks::probe_signal< int >::sptr":
    r"""probe_signal_i_make() -> probe_signal_i_sptr"""
    return _blocks_swig4.probe_signal_i_make()

class probe_signal_i_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::probe_signal< 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__(probe_signal_i_sptr self) -> probe_signal_i_sptr
        __init__(probe_signal_i_sptr self, probe_signal_i p) -> probe_signal_i_sptr
        """
        _blocks_swig4.probe_signal_i_sptr_swiginit(self, _blocks_swig4.new_probe_signal_i_sptr(*args))

    def __deref__(self) -> "gr::blocks::probe_signal< std::int32_t > *":
        r"""__deref__(probe_signal_i_sptr self) -> probe_signal_i"""
        return _blocks_swig4.probe_signal_i_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig4.delete_probe_signal_i_sptr

    def make(self) -> "gr::blocks::probe_signal< int >::sptr":
        r"""make(probe_signal_i_sptr self) -> probe_signal_i_sptr"""
        return _blocks_swig4.probe_signal_i_sptr_make(self)

    def level(self) -> "std::int32_t":
        r"""level(probe_signal_i_sptr self) -> std::int32_t"""
        return _blocks_swig4.probe_signal_i_sptr_level(self)

    def history(self) -> "unsigned int":
        r"""history(probe_signal_i_sptr self) -> unsigned int"""
        return _blocks_swig4.probe_signal_i_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(probe_signal_i_sptr self, int which, int delay)
        declare_sample_delay(probe_signal_i_sptr self, unsigned int delay)
        """
        return _blocks_swig4.probe_signal_i_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(probe_signal_i_sptr self, int which) -> unsigned int"""
        return _blocks_swig4.probe_signal_i_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(probe_signal_i_sptr self, int multiple)"""
        return _blocks_swig4.probe_signal_i_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(probe_signal_i_sptr self) -> int"""
        return _blocks_swig4.probe_signal_i_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(probe_signal_i_sptr self) -> double"""
        return _blocks_swig4.probe_signal_i_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(probe_signal_i_sptr self) -> uint64_t"""
        return _blocks_swig4.probe_signal_i_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(probe_signal_i_sptr self) -> uint64_t"""
        return _blocks_swig4.probe_signal_i_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(probe_signal_i_sptr self) -> bool"""
        return _blocks_swig4.probe_signal_i_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(probe_signal_i_sptr self) -> bool"""
        return _blocks_swig4.probe_signal_i_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(probe_signal_i_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig4.probe_signal_i_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(probe_signal_i_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig4.probe_signal_i_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(probe_signal_i_sptr self, std::string level)"""
        return _blocks_swig4.probe_signal_i_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(probe_signal_i_sptr self) -> std::string"""
        return _blocks_swig4.probe_signal_i_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(probe_signal_i_sptr self) -> int"""
        return _blocks_swig4.probe_signal_i_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(probe_signal_i_sptr self, int m)"""
        return _blocks_swig4.probe_signal_i_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(probe_signal_i_sptr self)"""
        return _blocks_swig4.probe_signal_i_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(probe_signal_i_sptr self) -> bool"""
        return _blocks_swig4.probe_signal_i_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(probe_signal_i_sptr self, int m)"""
        return _blocks_swig4.probe_signal_i_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(probe_signal_i_sptr self) -> int"""
        return _blocks_swig4.probe_signal_i_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(probe_signal_i_sptr self, int i) -> long"""
        return _blocks_swig4.probe_signal_i_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(probe_signal_i_sptr self, long max_output_buffer)
        set_max_output_buffer(probe_signal_i_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig4.probe_signal_i_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(probe_signal_i_sptr self, int i) -> long"""
        return _blocks_swig4.probe_signal_i_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(probe_signal_i_sptr self, long min_output_buffer)
        set_min_output_buffer(probe_signal_i_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig4.probe_signal_i_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(probe_signal_i_sptr self) -> float"""
        return _blocks_swig4.probe_signal_i_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(probe_signal_i_sptr self) -> float"""
        return _blocks_swig4.probe_signal_i_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(probe_signal_i_sptr self) -> float"""
        return _blocks_swig4.probe_signal_i_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(probe_signal_i_sptr self) -> float"""
        return _blocks_swig4.probe_signal_i_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(probe_signal_i_sptr self) -> float"""
        return _blocks_swig4.probe_signal_i_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(probe_signal_i_sptr self) -> float"""
        return _blocks_swig4.probe_signal_i_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(probe_signal_i_sptr self) -> float"""
        return _blocks_swig4.probe_signal_i_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(probe_signal_i_sptr self) -> float"""
        return _blocks_swig4.probe_signal_i_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(probe_signal_i_sptr self) -> float"""
        return _blocks_swig4.probe_signal_i_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(probe_signal_i_sptr self) -> float"""
        return _blocks_swig4.probe_signal_i_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(probe_signal_i_sptr self) -> float"""
        return _blocks_swig4.probe_signal_i_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(probe_signal_i_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig4.probe_signal_i_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(probe_signal_i_sptr self)"""
        return _blocks_swig4.probe_signal_i_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(probe_signal_i_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig4.probe_signal_i_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(probe_signal_i_sptr self) -> int"""
        return _blocks_swig4.probe_signal_i_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(probe_signal_i_sptr self) -> int"""
        return _blocks_swig4.probe_signal_i_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(probe_signal_i_sptr self, int priority) -> int"""
        return _blocks_swig4.probe_signal_i_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(probe_signal_i_sptr self) -> std::string"""
        return _blocks_swig4.probe_signal_i_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(probe_signal_i_sptr self) -> std::string"""
        return _blocks_swig4.probe_signal_i_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(probe_signal_i_sptr self) -> io_signature_sptr"""
        return _blocks_swig4.probe_signal_i_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(probe_signal_i_sptr self) -> io_signature_sptr"""
        return _blocks_swig4.probe_signal_i_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(probe_signal_i_sptr self) -> long"""
        return _blocks_swig4.probe_signal_i_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(probe_signal_i_sptr self) -> basic_block_sptr"""
        return _blocks_swig4.probe_signal_i_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(probe_signal_i_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig4.probe_signal_i_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(probe_signal_i_sptr self) -> std::string"""
        return _blocks_swig4.probe_signal_i_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(probe_signal_i_sptr self, std::string name)"""
        return _blocks_swig4.probe_signal_i_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(probe_signal_i_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig4.probe_signal_i_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(probe_signal_i_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig4.probe_signal_i_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(probe_signal_i_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig4.probe_signal_i_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(probe_signal_i_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig4.probe_signal_i_sptr_message_subscribers(self, which_port)

# Register probe_signal_i_sptr in _blocks_swig4:
_blocks_swig4.probe_signal_i_sptr_swigregister(probe_signal_i_sptr)


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

class probe_signal_f(object):
    r"""Proxy of C++ gr::blocks::probe_signal< 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

    @staticmethod
    def make() -> "gr::blocks::probe_signal< float >::sptr":
        r"""make() -> probe_signal_f_sptr"""
        return _blocks_swig4.probe_signal_f_make()

    def level(self) -> "float":
        r"""level(probe_signal_f self) -> float"""
        return _blocks_swig4.probe_signal_f_level(self)
    __swig_destroy__ = _blocks_swig4.delete_probe_signal_f

# Register probe_signal_f in _blocks_swig4:
_blocks_swig4.probe_signal_f_swigregister(probe_signal_f)

def probe_signal_f_make() -> "gr::blocks::probe_signal< float >::sptr":
    r"""probe_signal_f_make() -> probe_signal_f_sptr"""
    return _blocks_swig4.probe_signal_f_make()

class probe_signal_f_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::probe_signal< 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__(probe_signal_f_sptr self) -> probe_signal_f_sptr
        __init__(probe_signal_f_sptr self, probe_signal_f p) -> probe_signal_f_sptr
        """
        _blocks_swig4.probe_signal_f_sptr_swiginit(self, _blocks_swig4.new_probe_signal_f_sptr(*args))

    def __deref__(self) -> "gr::blocks::probe_signal< float > *":
        r"""__deref__(probe_signal_f_sptr self) -> probe_signal_f"""
        return _blocks_swig4.probe_signal_f_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig4.delete_probe_signal_f_sptr

    def make(self) -> "gr::blocks::probe_signal< float >::sptr":
        r"""make(probe_signal_f_sptr self) -> probe_signal_f_sptr"""
        return _blocks_swig4.probe_signal_f_sptr_make(self)

    def level(self) -> "float":
        r"""level(probe_signal_f_sptr self) -> float"""
        return _blocks_swig4.probe_signal_f_sptr_level(self)

    def history(self) -> "unsigned int":
        r"""history(probe_signal_f_sptr self) -> unsigned int"""
        return _blocks_swig4.probe_signal_f_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(probe_signal_f_sptr self, int which, int delay)
        declare_sample_delay(probe_signal_f_sptr self, unsigned int delay)
        """
        return _blocks_swig4.probe_signal_f_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(probe_signal_f_sptr self, int which) -> unsigned int"""
        return _blocks_swig4.probe_signal_f_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(probe_signal_f_sptr self, int multiple)"""
        return _blocks_swig4.probe_signal_f_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(probe_signal_f_sptr self) -> int"""
        return _blocks_swig4.probe_signal_f_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(probe_signal_f_sptr self) -> double"""
        return _blocks_swig4.probe_signal_f_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(probe_signal_f_sptr self) -> uint64_t"""
        return _blocks_swig4.probe_signal_f_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(probe_signal_f_sptr self) -> uint64_t"""
        return _blocks_swig4.probe_signal_f_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(probe_signal_f_sptr self) -> bool"""
        return _blocks_swig4.probe_signal_f_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(probe_signal_f_sptr self) -> bool"""
        return _blocks_swig4.probe_signal_f_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(probe_signal_f_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig4.probe_signal_f_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(probe_signal_f_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig4.probe_signal_f_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(probe_signal_f_sptr self, std::string level)"""
        return _blocks_swig4.probe_signal_f_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(probe_signal_f_sptr self) -> std::string"""
        return _blocks_swig4.probe_signal_f_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(probe_signal_f_sptr self) -> int"""
        return _blocks_swig4.probe_signal_f_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(probe_signal_f_sptr self, int m)"""
        return _blocks_swig4.probe_signal_f_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(probe_signal_f_sptr self)"""
        return _blocks_swig4.probe_signal_f_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(probe_signal_f_sptr self) -> bool"""
        return _blocks_swig4.probe_signal_f_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(probe_signal_f_sptr self, int m)"""
        return _blocks_swig4.probe_signal_f_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(probe_signal_f_sptr self) -> int"""
        return _blocks_swig4.probe_signal_f_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(probe_signal_f_sptr self, int i) -> long"""
        return _blocks_swig4.probe_signal_f_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(probe_signal_f_sptr self, long max_output_buffer)
        set_max_output_buffer(probe_signal_f_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig4.probe_signal_f_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(probe_signal_f_sptr self, int i) -> long"""
        return _blocks_swig4.probe_signal_f_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(probe_signal_f_sptr self, long min_output_buffer)
        set_min_output_buffer(probe_signal_f_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig4.probe_signal_f_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(probe_signal_f_sptr self) -> float"""
        return _blocks_swig4.probe_signal_f_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(probe_signal_f_sptr self) -> float"""
        return _blocks_swig4.probe_signal_f_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(probe_signal_f_sptr self) -> float"""
        return _blocks_swig4.probe_signal_f_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(probe_signal_f_sptr self) -> float"""
        return _blocks_swig4.probe_signal_f_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(probe_signal_f_sptr self) -> float"""
        return _blocks_swig4.probe_signal_f_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(probe_signal_f_sptr self) -> float"""
        return _blocks_swig4.probe_signal_f_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(probe_signal_f_sptr self) -> float"""
        return _blocks_swig4.probe_signal_f_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(probe_signal_f_sptr self) -> float"""
        return _blocks_swig4.probe_signal_f_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(probe_signal_f_sptr self) -> float"""
        return _blocks_swig4.probe_signal_f_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(probe_signal_f_sptr self) -> float"""
        return _blocks_swig4.probe_signal_f_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(probe_signal_f_sptr self) -> float"""
        return _blocks_swig4.probe_signal_f_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(probe_signal_f_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig4.probe_signal_f_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(probe_signal_f_sptr self)"""
        return _blocks_swig4.probe_signal_f_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(probe_signal_f_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig4.probe_signal_f_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(probe_signal_f_sptr self) -> int"""
        return _blocks_swig4.probe_signal_f_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(probe_signal_f_sptr self) -> int"""
        return _blocks_swig4.probe_signal_f_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(probe_signal_f_sptr self, int priority) -> int"""
        return _blocks_swig4.probe_signal_f_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(probe_signal_f_sptr self) -> std::string"""
        return _blocks_swig4.probe_signal_f_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(probe_signal_f_sptr self) -> std::string"""
        return _blocks_swig4.probe_signal_f_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(probe_signal_f_sptr self) -> io_signature_sptr"""
        return _blocks_swig4.probe_signal_f_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(probe_signal_f_sptr self) -> io_signature_sptr"""
        return _blocks_swig4.probe_signal_f_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(probe_signal_f_sptr self) -> long"""
        return _blocks_swig4.probe_signal_f_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(probe_signal_f_sptr self) -> basic_block_sptr"""
        return _blocks_swig4.probe_signal_f_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(probe_signal_f_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig4.probe_signal_f_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(probe_signal_f_sptr self) -> std::string"""
        return _blocks_swig4.probe_signal_f_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(probe_signal_f_sptr self, std::string name)"""
        return _blocks_swig4.probe_signal_f_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(probe_signal_f_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig4.probe_signal_f_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(probe_signal_f_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig4.probe_signal_f_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(probe_signal_f_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig4.probe_signal_f_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(probe_signal_f_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig4.probe_signal_f_sptr_message_subscribers(self, which_port)

# Register probe_signal_f_sptr in _blocks_swig4:
_blocks_swig4.probe_signal_f_sptr_swigregister(probe_signal_f_sptr)


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

class probe_signal_c(object):
    r"""Proxy of C++ gr::blocks::probe_signal< 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

    @staticmethod
    def make() -> "gr::blocks::probe_signal< std::complex< float > >::sptr":
        r"""make() -> probe_signal_c_sptr"""
        return _blocks_swig4.probe_signal_c_make()

    def level(self) -> "std::complex< float >":
        r"""level(probe_signal_c self) -> std::complex< float >"""
        return _blocks_swig4.probe_signal_c_level(self)
    __swig_destroy__ = _blocks_swig4.delete_probe_signal_c

# Register probe_signal_c in _blocks_swig4:
_blocks_swig4.probe_signal_c_swigregister(probe_signal_c)

def probe_signal_c_make() -> "gr::blocks::probe_signal< std::complex< float > >::sptr":
    r"""probe_signal_c_make() -> probe_signal_c_sptr"""
    return _blocks_swig4.probe_signal_c_make()

class probe_signal_c_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::probe_signal< 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__(probe_signal_c_sptr self) -> probe_signal_c_sptr
        __init__(probe_signal_c_sptr self, probe_signal_c p) -> probe_signal_c_sptr
        """
        _blocks_swig4.probe_signal_c_sptr_swiginit(self, _blocks_swig4.new_probe_signal_c_sptr(*args))

    def __deref__(self) -> "gr::blocks::probe_signal< gr_complex > *":
        r"""__deref__(probe_signal_c_sptr self) -> probe_signal_c"""
        return _blocks_swig4.probe_signal_c_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig4.delete_probe_signal_c_sptr

    def make(self) -> "gr::blocks::probe_signal< std::complex< float > >::sptr":
        r"""make(probe_signal_c_sptr self) -> probe_signal_c_sptr"""
        return _blocks_swig4.probe_signal_c_sptr_make(self)

    def level(self) -> "std::complex< float >":
        r"""level(probe_signal_c_sptr self) -> std::complex< float >"""
        return _blocks_swig4.probe_signal_c_sptr_level(self)

    def history(self) -> "unsigned int":
        r"""history(probe_signal_c_sptr self) -> unsigned int"""
        return _blocks_swig4.probe_signal_c_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(probe_signal_c_sptr self, int which, int delay)
        declare_sample_delay(probe_signal_c_sptr self, unsigned int delay)
        """
        return _blocks_swig4.probe_signal_c_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(probe_signal_c_sptr self, int which) -> unsigned int"""
        return _blocks_swig4.probe_signal_c_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(probe_signal_c_sptr self, int multiple)"""
        return _blocks_swig4.probe_signal_c_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(probe_signal_c_sptr self) -> int"""
        return _blocks_swig4.probe_signal_c_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(probe_signal_c_sptr self) -> double"""
        return _blocks_swig4.probe_signal_c_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(probe_signal_c_sptr self) -> uint64_t"""
        return _blocks_swig4.probe_signal_c_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(probe_signal_c_sptr self) -> uint64_t"""
        return _blocks_swig4.probe_signal_c_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(probe_signal_c_sptr self) -> bool"""
        return _blocks_swig4.probe_signal_c_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(probe_signal_c_sptr self) -> bool"""
        return _blocks_swig4.probe_signal_c_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(probe_signal_c_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig4.probe_signal_c_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(probe_signal_c_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig4.probe_signal_c_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(probe_signal_c_sptr self, std::string level)"""
        return _blocks_swig4.probe_signal_c_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(probe_signal_c_sptr self) -> std::string"""
        return _blocks_swig4.probe_signal_c_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(probe_signal_c_sptr self) -> int"""
        return _blocks_swig4.probe_signal_c_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(probe_signal_c_sptr self, int m)"""
        return _blocks_swig4.probe_signal_c_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(probe_signal_c_sptr self)"""
        return _blocks_swig4.probe_signal_c_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(probe_signal_c_sptr self) -> bool"""
        return _blocks_swig4.probe_signal_c_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(probe_signal_c_sptr self, int m)"""
        return _blocks_swig4.probe_signal_c_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(probe_signal_c_sptr self) -> int"""
        return _blocks_swig4.probe_signal_c_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(probe_signal_c_sptr self, int i) -> long"""
        return _blocks_swig4.probe_signal_c_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(probe_signal_c_sptr self, long max_output_buffer)
        set_max_output_buffer(probe_signal_c_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig4.probe_signal_c_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(probe_signal_c_sptr self, int i) -> long"""
        return _blocks_swig4.probe_signal_c_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(probe_signal_c_sptr self, long min_output_buffer)
        set_min_output_buffer(probe_signal_c_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig4.probe_signal_c_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(probe_signal_c_sptr self) -> float"""
        return _blocks_swig4.probe_signal_c_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(probe_signal_c_sptr self) -> float"""
        return _blocks_swig4.probe_signal_c_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(probe_signal_c_sptr self) -> float"""
        return _blocks_swig4.probe_signal_c_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(probe_signal_c_sptr self) -> float"""
        return _blocks_swig4.probe_signal_c_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(probe_signal_c_sptr self) -> float"""
        return _blocks_swig4.probe_signal_c_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(probe_signal_c_sptr self) -> float"""
        return _blocks_swig4.probe_signal_c_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(probe_signal_c_sptr self) -> float"""
        return _blocks_swig4.probe_signal_c_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(probe_signal_c_sptr self) -> float"""
        return _blocks_swig4.probe_signal_c_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(probe_signal_c_sptr self) -> float"""
        return _blocks_swig4.probe_signal_c_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(probe_signal_c_sptr self) -> float"""
        return _blocks_swig4.probe_signal_c_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(probe_signal_c_sptr self) -> float"""
        return _blocks_swig4.probe_signal_c_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(probe_signal_c_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig4.probe_signal_c_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(probe_signal_c_sptr self)"""
        return _blocks_swig4.probe_signal_c_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(probe_signal_c_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig4.probe_signal_c_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(probe_signal_c_sptr self) -> int"""
        return _blocks_swig4.probe_signal_c_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(probe_signal_c_sptr self) -> int"""
        return _blocks_swig4.probe_signal_c_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(probe_signal_c_sptr self, int priority) -> int"""
        return _blocks_swig4.probe_signal_c_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(probe_signal_c_sptr self) -> std::string"""
        return _blocks_swig4.probe_signal_c_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(probe_signal_c_sptr self) -> std::string"""
        return _blocks_swig4.probe_signal_c_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(probe_signal_c_sptr self) -> io_signature_sptr"""
        return _blocks_swig4.probe_signal_c_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(probe_signal_c_sptr self) -> io_signature_sptr"""
        return _blocks_swig4.probe_signal_c_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(probe_signal_c_sptr self) -> long"""
        return _blocks_swig4.probe_signal_c_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(probe_signal_c_sptr self) -> basic_block_sptr"""
        return _blocks_swig4.probe_signal_c_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(probe_signal_c_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig4.probe_signal_c_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(probe_signal_c_sptr self) -> std::string"""
        return _blocks_swig4.probe_signal_c_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(probe_signal_c_sptr self, std::string name)"""
        return _blocks_swig4.probe_signal_c_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(probe_signal_c_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig4.probe_signal_c_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(probe_signal_c_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig4.probe_signal_c_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(probe_signal_c_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig4.probe_signal_c_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(probe_signal_c_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig4.probe_signal_c_sptr_message_subscribers(self, which_port)

# Register probe_signal_c_sptr in _blocks_swig4:
_blocks_swig4.probe_signal_c_sptr_swigregister(probe_signal_c_sptr)


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

class probe_signal_vb(object):
    r"""Proxy of C++ gr::blocks::probe_signal_v< 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

    @staticmethod
    def make(size: "size_t") -> "gr::blocks::probe_signal_v< unsigned char >::sptr":
        r"""make(size_t size) -> probe_signal_vb_sptr"""
        return _blocks_swig4.probe_signal_vb_make(size)

    def level(self) -> "std::vector< std::uint8_t,std::allocator< std::uint8_t > >":
        r"""level(probe_signal_vb self) -> std::vector< std::uint8_t,std::allocator< std::uint8_t > >"""
        return _blocks_swig4.probe_signal_vb_level(self)
    __swig_destroy__ = _blocks_swig4.delete_probe_signal_vb

# Register probe_signal_vb in _blocks_swig4:
_blocks_swig4.probe_signal_vb_swigregister(probe_signal_vb)

def probe_signal_vb_make(size: "size_t") -> "gr::blocks::probe_signal_v< unsigned char >::sptr":
    r"""probe_signal_vb_make(size_t size) -> probe_signal_vb_sptr"""
    return _blocks_swig4.probe_signal_vb_make(size)

class probe_signal_vb_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::probe_signal_v< 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__(probe_signal_vb_sptr self) -> probe_signal_vb_sptr
        __init__(probe_signal_vb_sptr self, probe_signal_vb p) -> probe_signal_vb_sptr
        """
        _blocks_swig4.probe_signal_vb_sptr_swiginit(self, _blocks_swig4.new_probe_signal_vb_sptr(*args))

    def __deref__(self) -> "gr::blocks::probe_signal_v< std::uint8_t > *":
        r"""__deref__(probe_signal_vb_sptr self) -> probe_signal_vb"""
        return _blocks_swig4.probe_signal_vb_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig4.delete_probe_signal_vb_sptr

    def make(self, size: "size_t") -> "gr::blocks::probe_signal_v< unsigned char >::sptr":
        r"""make(probe_signal_vb_sptr self, size_t size) -> probe_signal_vb_sptr"""
        return _blocks_swig4.probe_signal_vb_sptr_make(self, size)

    def level(self) -> "std::vector< std::uint8_t,std::allocator< std::uint8_t > >":
        r"""level(probe_signal_vb_sptr self) -> std::vector< std::uint8_t,std::allocator< std::uint8_t > >"""
        return _blocks_swig4.probe_signal_vb_sptr_level(self)

    def history(self) -> "unsigned int":
        r"""history(probe_signal_vb_sptr self) -> unsigned int"""
        return _blocks_swig4.probe_signal_vb_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(probe_signal_vb_sptr self, int which, int delay)
        declare_sample_delay(probe_signal_vb_sptr self, unsigned int delay)
        """
        return _blocks_swig4.probe_signal_vb_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(probe_signal_vb_sptr self, int which) -> unsigned int"""
        return _blocks_swig4.probe_signal_vb_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(probe_signal_vb_sptr self, int multiple)"""
        return _blocks_swig4.probe_signal_vb_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(probe_signal_vb_sptr self) -> int"""
        return _blocks_swig4.probe_signal_vb_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(probe_signal_vb_sptr self) -> double"""
        return _blocks_swig4.probe_signal_vb_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(probe_signal_vb_sptr self) -> uint64_t"""
        return _blocks_swig4.probe_signal_vb_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(probe_signal_vb_sptr self) -> uint64_t"""
        return _blocks_swig4.probe_signal_vb_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(probe_signal_vb_sptr self) -> bool"""
        return _blocks_swig4.probe_signal_vb_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(probe_signal_vb_sptr self) -> bool"""
        return _blocks_swig4.probe_signal_vb_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(probe_signal_vb_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig4.probe_signal_vb_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(probe_signal_vb_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig4.probe_signal_vb_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(probe_signal_vb_sptr self, std::string level)"""
        return _blocks_swig4.probe_signal_vb_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(probe_signal_vb_sptr self) -> std::string"""
        return _blocks_swig4.probe_signal_vb_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(probe_signal_vb_sptr self) -> int"""
        return _blocks_swig4.probe_signal_vb_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(probe_signal_vb_sptr self, int m)"""
        return _blocks_swig4.probe_signal_vb_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(probe_signal_vb_sptr self)"""
        return _blocks_swig4.probe_signal_vb_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(probe_signal_vb_sptr self) -> bool"""
        return _blocks_swig4.probe_signal_vb_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(probe_signal_vb_sptr self, int m)"""
        return _blocks_swig4.probe_signal_vb_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(probe_signal_vb_sptr self) -> int"""
        return _blocks_swig4.probe_signal_vb_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(probe_signal_vb_sptr self, int i) -> long"""
        return _blocks_swig4.probe_signal_vb_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(probe_signal_vb_sptr self, long max_output_buffer)
        set_max_output_buffer(probe_signal_vb_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig4.probe_signal_vb_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(probe_signal_vb_sptr self, int i) -> long"""
        return _blocks_swig4.probe_signal_vb_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(probe_signal_vb_sptr self, long min_output_buffer)
        set_min_output_buffer(probe_signal_vb_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig4.probe_signal_vb_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(probe_signal_vb_sptr self) -> float"""
        return _blocks_swig4.probe_signal_vb_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(probe_signal_vb_sptr self) -> float"""
        return _blocks_swig4.probe_signal_vb_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(probe_signal_vb_sptr self) -> float"""
        return _blocks_swig4.probe_signal_vb_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(probe_signal_vb_sptr self) -> float"""
        return _blocks_swig4.probe_signal_vb_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(probe_signal_vb_sptr self) -> float"""
        return _blocks_swig4.probe_signal_vb_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(probe_signal_vb_sptr self) -> float"""
        return _blocks_swig4.probe_signal_vb_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(probe_signal_vb_sptr self) -> float"""
        return _blocks_swig4.probe_signal_vb_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(probe_signal_vb_sptr self) -> float"""
        return _blocks_swig4.probe_signal_vb_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(probe_signal_vb_sptr self) -> float"""
        return _blocks_swig4.probe_signal_vb_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(probe_signal_vb_sptr self) -> float"""
        return _blocks_swig4.probe_signal_vb_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(probe_signal_vb_sptr self) -> float"""
        return _blocks_swig4.probe_signal_vb_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(probe_signal_vb_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig4.probe_signal_vb_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(probe_signal_vb_sptr self)"""
        return _blocks_swig4.probe_signal_vb_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(probe_signal_vb_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig4.probe_signal_vb_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(probe_signal_vb_sptr self) -> int"""
        return _blocks_swig4.probe_signal_vb_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(probe_signal_vb_sptr self) -> int"""
        return _blocks_swig4.probe_signal_vb_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(probe_signal_vb_sptr self, int priority) -> int"""
        return _blocks_swig4.probe_signal_vb_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(probe_signal_vb_sptr self) -> std::string"""
        return _blocks_swig4.probe_signal_vb_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(probe_signal_vb_sptr self) -> std::string"""
        return _blocks_swig4.probe_signal_vb_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(probe_signal_vb_sptr self) -> io_signature_sptr"""
        return _blocks_swig4.probe_signal_vb_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(probe_signal_vb_sptr self) -> io_signature_sptr"""
        return _blocks_swig4.probe_signal_vb_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(probe_signal_vb_sptr self) -> long"""
        return _blocks_swig4.probe_signal_vb_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(probe_signal_vb_sptr self) -> basic_block_sptr"""
        return _blocks_swig4.probe_signal_vb_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(probe_signal_vb_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig4.probe_signal_vb_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(probe_signal_vb_sptr self) -> std::string"""
        return _blocks_swig4.probe_signal_vb_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(probe_signal_vb_sptr self, std::string name)"""
        return _blocks_swig4.probe_signal_vb_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(probe_signal_vb_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig4.probe_signal_vb_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(probe_signal_vb_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig4.probe_signal_vb_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(probe_signal_vb_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig4.probe_signal_vb_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(probe_signal_vb_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig4.probe_signal_vb_sptr_message_subscribers(self, which_port)

# Register probe_signal_vb_sptr in _blocks_swig4:
_blocks_swig4.probe_signal_vb_sptr_swigregister(probe_signal_vb_sptr)


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

class probe_signal_vs(object):
    r"""Proxy of C++ gr::blocks::probe_signal_v< 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

    @staticmethod
    def make(size: "size_t") -> "gr::blocks::probe_signal_v< short >::sptr":
        r"""make(size_t size) -> probe_signal_vs_sptr"""
        return _blocks_swig4.probe_signal_vs_make(size)

    def level(self) -> "std::vector< std::int16_t,std::allocator< std::int16_t > >":
        r"""level(probe_signal_vs self) -> std::vector< std::int16_t,std::allocator< std::int16_t > >"""
        return _blocks_swig4.probe_signal_vs_level(self)
    __swig_destroy__ = _blocks_swig4.delete_probe_signal_vs

# Register probe_signal_vs in _blocks_swig4:
_blocks_swig4.probe_signal_vs_swigregister(probe_signal_vs)

def probe_signal_vs_make(size: "size_t") -> "gr::blocks::probe_signal_v< short >::sptr":
    r"""probe_signal_vs_make(size_t size) -> probe_signal_vs_sptr"""
    return _blocks_swig4.probe_signal_vs_make(size)

class probe_signal_vs_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::probe_signal_v< 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__(probe_signal_vs_sptr self) -> probe_signal_vs_sptr
        __init__(probe_signal_vs_sptr self, probe_signal_vs p) -> probe_signal_vs_sptr
        """
        _blocks_swig4.probe_signal_vs_sptr_swiginit(self, _blocks_swig4.new_probe_signal_vs_sptr(*args))

    def __deref__(self) -> "gr::blocks::probe_signal_v< std::int16_t > *":
        r"""__deref__(probe_signal_vs_sptr self) -> probe_signal_vs"""
        return _blocks_swig4.probe_signal_vs_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig4.delete_probe_signal_vs_sptr

    def make(self, size: "size_t") -> "gr::blocks::probe_signal_v< short >::sptr":
        r"""make(probe_signal_vs_sptr self, size_t size) -> probe_signal_vs_sptr"""
        return _blocks_swig4.probe_signal_vs_sptr_make(self, size)

    def level(self) -> "std::vector< std::int16_t,std::allocator< std::int16_t > >":
        r"""level(probe_signal_vs_sptr self) -> std::vector< std::int16_t,std::allocator< std::int16_t > >"""
        return _blocks_swig4.probe_signal_vs_sptr_level(self)

    def history(self) -> "unsigned int":
        r"""history(probe_signal_vs_sptr self) -> unsigned int"""
        return _blocks_swig4.probe_signal_vs_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(probe_signal_vs_sptr self, int which, int delay)
        declare_sample_delay(probe_signal_vs_sptr self, unsigned int delay)
        """
        return _blocks_swig4.probe_signal_vs_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(probe_signal_vs_sptr self, int which) -> unsigned int"""
        return _blocks_swig4.probe_signal_vs_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(probe_signal_vs_sptr self, int multiple)"""
        return _blocks_swig4.probe_signal_vs_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(probe_signal_vs_sptr self) -> int"""
        return _blocks_swig4.probe_signal_vs_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(probe_signal_vs_sptr self) -> double"""
        return _blocks_swig4.probe_signal_vs_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(probe_signal_vs_sptr self) -> uint64_t"""
        return _blocks_swig4.probe_signal_vs_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(probe_signal_vs_sptr self) -> uint64_t"""
        return _blocks_swig4.probe_signal_vs_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(probe_signal_vs_sptr self) -> bool"""
        return _blocks_swig4.probe_signal_vs_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(probe_signal_vs_sptr self) -> bool"""
        return _blocks_swig4.probe_signal_vs_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(probe_signal_vs_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig4.probe_signal_vs_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(probe_signal_vs_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig4.probe_signal_vs_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(probe_signal_vs_sptr self, std::string level)"""
        return _blocks_swig4.probe_signal_vs_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(probe_signal_vs_sptr self) -> std::string"""
        return _blocks_swig4.probe_signal_vs_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(probe_signal_vs_sptr self) -> int"""
        return _blocks_swig4.probe_signal_vs_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(probe_signal_vs_sptr self, int m)"""
        return _blocks_swig4.probe_signal_vs_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(probe_signal_vs_sptr self)"""
        return _blocks_swig4.probe_signal_vs_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(probe_signal_vs_sptr self) -> bool"""
        return _blocks_swig4.probe_signal_vs_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(probe_signal_vs_sptr self, int m)"""
        return _blocks_swig4.probe_signal_vs_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(probe_signal_vs_sptr self) -> int"""
        return _blocks_swig4.probe_signal_vs_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(probe_signal_vs_sptr self, int i) -> long"""
        return _blocks_swig4.probe_signal_vs_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(probe_signal_vs_sptr self, long max_output_buffer)
        set_max_output_buffer(probe_signal_vs_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig4.probe_signal_vs_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(probe_signal_vs_sptr self, int i) -> long"""
        return _blocks_swig4.probe_signal_vs_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(probe_signal_vs_sptr self, long min_output_buffer)
        set_min_output_buffer(probe_signal_vs_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig4.probe_signal_vs_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(probe_signal_vs_sptr self) -> float"""
        return _blocks_swig4.probe_signal_vs_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(probe_signal_vs_sptr self) -> float"""
        return _blocks_swig4.probe_signal_vs_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(probe_signal_vs_sptr self) -> float"""
        return _blocks_swig4.probe_signal_vs_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(probe_signal_vs_sptr self) -> float"""
        return _blocks_swig4.probe_signal_vs_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(probe_signal_vs_sptr self) -> float"""
        return _blocks_swig4.probe_signal_vs_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(probe_signal_vs_sptr self) -> float"""
        return _blocks_swig4.probe_signal_vs_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(probe_signal_vs_sptr self) -> float"""
        return _blocks_swig4.probe_signal_vs_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(probe_signal_vs_sptr self) -> float"""
        return _blocks_swig4.probe_signal_vs_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(probe_signal_vs_sptr self) -> float"""
        return _blocks_swig4.probe_signal_vs_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(probe_signal_vs_sptr self) -> float"""
        return _blocks_swig4.probe_signal_vs_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(probe_signal_vs_sptr self) -> float"""
        return _blocks_swig4.probe_signal_vs_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(probe_signal_vs_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig4.probe_signal_vs_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(probe_signal_vs_sptr self)"""
        return _blocks_swig4.probe_signal_vs_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(probe_signal_vs_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig4.probe_signal_vs_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(probe_signal_vs_sptr self) -> int"""
        return _blocks_swig4.probe_signal_vs_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(probe_signal_vs_sptr self) -> int"""
        return _blocks_swig4.probe_signal_vs_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(probe_signal_vs_sptr self, int priority) -> int"""
        return _blocks_swig4.probe_signal_vs_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(probe_signal_vs_sptr self) -> std::string"""
        return _blocks_swig4.probe_signal_vs_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(probe_signal_vs_sptr self) -> std::string"""
        return _blocks_swig4.probe_signal_vs_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(probe_signal_vs_sptr self) -> io_signature_sptr"""
        return _blocks_swig4.probe_signal_vs_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(probe_signal_vs_sptr self) -> io_signature_sptr"""
        return _blocks_swig4.probe_signal_vs_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(probe_signal_vs_sptr self) -> long"""
        return _blocks_swig4.probe_signal_vs_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(probe_signal_vs_sptr self) -> basic_block_sptr"""
        return _blocks_swig4.probe_signal_vs_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(probe_signal_vs_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig4.probe_signal_vs_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(probe_signal_vs_sptr self) -> std::string"""
        return _blocks_swig4.probe_signal_vs_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(probe_signal_vs_sptr self, std::string name)"""
        return _blocks_swig4.probe_signal_vs_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(probe_signal_vs_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig4.probe_signal_vs_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(probe_signal_vs_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig4.probe_signal_vs_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(probe_signal_vs_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig4.probe_signal_vs_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(probe_signal_vs_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig4.probe_signal_vs_sptr_message_subscribers(self, which_port)

# Register probe_signal_vs_sptr in _blocks_swig4:
_blocks_swig4.probe_signal_vs_sptr_swigregister(probe_signal_vs_sptr)


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

class probe_signal_vi(object):
    r"""Proxy of C++ gr::blocks::probe_signal_v< 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

    @staticmethod
    def make(size: "size_t") -> "gr::blocks::probe_signal_v< int >::sptr":
        r"""make(size_t size) -> probe_signal_vi_sptr"""
        return _blocks_swig4.probe_signal_vi_make(size)

    def level(self) -> "std::vector< std::int32_t,std::allocator< std::int32_t > >":
        r"""level(probe_signal_vi self) -> std::vector< std::int32_t,std::allocator< std::int32_t > >"""
        return _blocks_swig4.probe_signal_vi_level(self)
    __swig_destroy__ = _blocks_swig4.delete_probe_signal_vi

# Register probe_signal_vi in _blocks_swig4:
_blocks_swig4.probe_signal_vi_swigregister(probe_signal_vi)

def probe_signal_vi_make(size: "size_t") -> "gr::blocks::probe_signal_v< int >::sptr":
    r"""probe_signal_vi_make(size_t size) -> probe_signal_vi_sptr"""
    return _blocks_swig4.probe_signal_vi_make(size)

class probe_signal_vi_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::probe_signal_v< 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__(probe_signal_vi_sptr self) -> probe_signal_vi_sptr
        __init__(probe_signal_vi_sptr self, probe_signal_vi p) -> probe_signal_vi_sptr
        """
        _blocks_swig4.probe_signal_vi_sptr_swiginit(self, _blocks_swig4.new_probe_signal_vi_sptr(*args))

    def __deref__(self) -> "gr::blocks::probe_signal_v< std::int32_t > *":
        r"""__deref__(probe_signal_vi_sptr self) -> probe_signal_vi"""
        return _blocks_swig4.probe_signal_vi_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig4.delete_probe_signal_vi_sptr

    def make(self, size: "size_t") -> "gr::blocks::probe_signal_v< int >::sptr":
        r"""make(probe_signal_vi_sptr self, size_t size) -> probe_signal_vi_sptr"""
        return _blocks_swig4.probe_signal_vi_sptr_make(self, size)

    def level(self) -> "std::vector< std::int32_t,std::allocator< std::int32_t > >":
        r"""level(probe_signal_vi_sptr self) -> std::vector< std::int32_t,std::allocator< std::int32_t > >"""
        return _blocks_swig4.probe_signal_vi_sptr_level(self)

    def history(self) -> "unsigned int":
        r"""history(probe_signal_vi_sptr self) -> unsigned int"""
        return _blocks_swig4.probe_signal_vi_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(probe_signal_vi_sptr self, int which, int delay)
        declare_sample_delay(probe_signal_vi_sptr self, unsigned int delay)
        """
        return _blocks_swig4.probe_signal_vi_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(probe_signal_vi_sptr self, int which) -> unsigned int"""
        return _blocks_swig4.probe_signal_vi_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(probe_signal_vi_sptr self, int multiple)"""
        return _blocks_swig4.probe_signal_vi_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(probe_signal_vi_sptr self) -> int"""
        return _blocks_swig4.probe_signal_vi_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(probe_signal_vi_sptr self) -> double"""
        return _blocks_swig4.probe_signal_vi_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(probe_signal_vi_sptr self) -> uint64_t"""
        return _blocks_swig4.probe_signal_vi_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(probe_signal_vi_sptr self) -> uint64_t"""
        return _blocks_swig4.probe_signal_vi_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(probe_signal_vi_sptr self) -> bool"""
        return _blocks_swig4.probe_signal_vi_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(probe_signal_vi_sptr self) -> bool"""
        return _blocks_swig4.probe_signal_vi_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(probe_signal_vi_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig4.probe_signal_vi_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(probe_signal_vi_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig4.probe_signal_vi_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(probe_signal_vi_sptr self, std::string level)"""
        return _blocks_swig4.probe_signal_vi_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(probe_signal_vi_sptr self) -> std::string"""
        return _blocks_swig4.probe_signal_vi_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(probe_signal_vi_sptr self) -> int"""
        return _blocks_swig4.probe_signal_vi_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(probe_signal_vi_sptr self, int m)"""
        return _blocks_swig4.probe_signal_vi_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(probe_signal_vi_sptr self)"""
        return _blocks_swig4.probe_signal_vi_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(probe_signal_vi_sptr self) -> bool"""
        return _blocks_swig4.probe_signal_vi_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(probe_signal_vi_sptr self, int m)"""
        return _blocks_swig4.probe_signal_vi_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(probe_signal_vi_sptr self) -> int"""
        return _blocks_swig4.probe_signal_vi_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(probe_signal_vi_sptr self, int i) -> long"""
        return _blocks_swig4.probe_signal_vi_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(probe_signal_vi_sptr self, long max_output_buffer)
        set_max_output_buffer(probe_signal_vi_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig4.probe_signal_vi_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(probe_signal_vi_sptr self, int i) -> long"""
        return _blocks_swig4.probe_signal_vi_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(probe_signal_vi_sptr self, long min_output_buffer)
        set_min_output_buffer(probe_signal_vi_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig4.probe_signal_vi_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(probe_signal_vi_sptr self) -> float"""
        return _blocks_swig4.probe_signal_vi_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(probe_signal_vi_sptr self) -> float"""
        return _blocks_swig4.probe_signal_vi_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(probe_signal_vi_sptr self) -> float"""
        return _blocks_swig4.probe_signal_vi_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(probe_signal_vi_sptr self) -> float"""
        return _blocks_swig4.probe_signal_vi_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(probe_signal_vi_sptr self) -> float"""
        return _blocks_swig4.probe_signal_vi_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(probe_signal_vi_sptr self) -> float"""
        return _blocks_swig4.probe_signal_vi_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(probe_signal_vi_sptr self) -> float"""
        return _blocks_swig4.probe_signal_vi_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(probe_signal_vi_sptr self) -> float"""
        return _blocks_swig4.probe_signal_vi_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(probe_signal_vi_sptr self) -> float"""
        return _blocks_swig4.probe_signal_vi_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(probe_signal_vi_sptr self) -> float"""
        return _blocks_swig4.probe_signal_vi_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(probe_signal_vi_sptr self) -> float"""
        return _blocks_swig4.probe_signal_vi_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(probe_signal_vi_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig4.probe_signal_vi_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(probe_signal_vi_sptr self)"""
        return _blocks_swig4.probe_signal_vi_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(probe_signal_vi_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig4.probe_signal_vi_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(probe_signal_vi_sptr self) -> int"""
        return _blocks_swig4.probe_signal_vi_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(probe_signal_vi_sptr self) -> int"""
        return _blocks_swig4.probe_signal_vi_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(probe_signal_vi_sptr self, int priority) -> int"""
        return _blocks_swig4.probe_signal_vi_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(probe_signal_vi_sptr self) -> std::string"""
        return _blocks_swig4.probe_signal_vi_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(probe_signal_vi_sptr self) -> std::string"""
        return _blocks_swig4.probe_signal_vi_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(probe_signal_vi_sptr self) -> io_signature_sptr"""
        return _blocks_swig4.probe_signal_vi_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(probe_signal_vi_sptr self) -> io_signature_sptr"""
        return _blocks_swig4.probe_signal_vi_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(probe_signal_vi_sptr self) -> long"""
        return _blocks_swig4.probe_signal_vi_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(probe_signal_vi_sptr self) -> basic_block_sptr"""
        return _blocks_swig4.probe_signal_vi_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(probe_signal_vi_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig4.probe_signal_vi_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(probe_signal_vi_sptr self) -> std::string"""
        return _blocks_swig4.probe_signal_vi_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(probe_signal_vi_sptr self, std::string name)"""
        return _blocks_swig4.probe_signal_vi_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(probe_signal_vi_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig4.probe_signal_vi_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(probe_signal_vi_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig4.probe_signal_vi_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(probe_signal_vi_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig4.probe_signal_vi_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(probe_signal_vi_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig4.probe_signal_vi_sptr_message_subscribers(self, which_port)

# Register probe_signal_vi_sptr in _blocks_swig4:
_blocks_swig4.probe_signal_vi_sptr_swigregister(probe_signal_vi_sptr)


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

class probe_signal_vf(object):
    r"""Proxy of C++ gr::blocks::probe_signal_v< 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

    @staticmethod
    def make(size: "size_t") -> "gr::blocks::probe_signal_v< float >::sptr":
        r"""make(size_t size) -> probe_signal_vf_sptr"""
        return _blocks_swig4.probe_signal_vf_make(size)

    def level(self) -> "std::vector< float,std::allocator< float > >":
        r"""level(probe_signal_vf self) -> pmt_vector_float"""
        return _blocks_swig4.probe_signal_vf_level(self)
    __swig_destroy__ = _blocks_swig4.delete_probe_signal_vf

# Register probe_signal_vf in _blocks_swig4:
_blocks_swig4.probe_signal_vf_swigregister(probe_signal_vf)

def probe_signal_vf_make(size: "size_t") -> "gr::blocks::probe_signal_v< float >::sptr":
    r"""probe_signal_vf_make(size_t size) -> probe_signal_vf_sptr"""
    return _blocks_swig4.probe_signal_vf_make(size)

class probe_signal_vf_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::probe_signal_v< 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__(probe_signal_vf_sptr self) -> probe_signal_vf_sptr
        __init__(probe_signal_vf_sptr self, probe_signal_vf p) -> probe_signal_vf_sptr
        """
        _blocks_swig4.probe_signal_vf_sptr_swiginit(self, _blocks_swig4.new_probe_signal_vf_sptr(*args))

    def __deref__(self) -> "gr::blocks::probe_signal_v< float > *":
        r"""__deref__(probe_signal_vf_sptr self) -> probe_signal_vf"""
        return _blocks_swig4.probe_signal_vf_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig4.delete_probe_signal_vf_sptr

    def make(self, size: "size_t") -> "gr::blocks::probe_signal_v< float >::sptr":
        r"""make(probe_signal_vf_sptr self, size_t size) -> probe_signal_vf_sptr"""
        return _blocks_swig4.probe_signal_vf_sptr_make(self, size)

    def level(self) -> "std::vector< float,std::allocator< float > >":
        r"""level(probe_signal_vf_sptr self) -> pmt_vector_float"""
        return _blocks_swig4.probe_signal_vf_sptr_level(self)

    def history(self) -> "unsigned int":
        r"""history(probe_signal_vf_sptr self) -> unsigned int"""
        return _blocks_swig4.probe_signal_vf_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(probe_signal_vf_sptr self, int which, int delay)
        declare_sample_delay(probe_signal_vf_sptr self, unsigned int delay)
        """
        return _blocks_swig4.probe_signal_vf_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(probe_signal_vf_sptr self, int which) -> unsigned int"""
        return _blocks_swig4.probe_signal_vf_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(probe_signal_vf_sptr self, int multiple)"""
        return _blocks_swig4.probe_signal_vf_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(probe_signal_vf_sptr self) -> int"""
        return _blocks_swig4.probe_signal_vf_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(probe_signal_vf_sptr self) -> double"""
        return _blocks_swig4.probe_signal_vf_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(probe_signal_vf_sptr self) -> uint64_t"""
        return _blocks_swig4.probe_signal_vf_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(probe_signal_vf_sptr self) -> uint64_t"""
        return _blocks_swig4.probe_signal_vf_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(probe_signal_vf_sptr self) -> bool"""
        return _blocks_swig4.probe_signal_vf_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(probe_signal_vf_sptr self) -> bool"""
        return _blocks_swig4.probe_signal_vf_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(probe_signal_vf_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig4.probe_signal_vf_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(probe_signal_vf_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig4.probe_signal_vf_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(probe_signal_vf_sptr self, std::string level)"""
        return _blocks_swig4.probe_signal_vf_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(probe_signal_vf_sptr self) -> std::string"""
        return _blocks_swig4.probe_signal_vf_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(probe_signal_vf_sptr self) -> int"""
        return _blocks_swig4.probe_signal_vf_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(probe_signal_vf_sptr self, int m)"""
        return _blocks_swig4.probe_signal_vf_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(probe_signal_vf_sptr self)"""
        return _blocks_swig4.probe_signal_vf_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(probe_signal_vf_sptr self) -> bool"""
        return _blocks_swig4.probe_signal_vf_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(probe_signal_vf_sptr self, int m)"""
        return _blocks_swig4.probe_signal_vf_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(probe_signal_vf_sptr self) -> int"""
        return _blocks_swig4.probe_signal_vf_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(probe_signal_vf_sptr self, int i) -> long"""
        return _blocks_swig4.probe_signal_vf_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(probe_signal_vf_sptr self, long max_output_buffer)
        set_max_output_buffer(probe_signal_vf_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig4.probe_signal_vf_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(probe_signal_vf_sptr self, int i) -> long"""
        return _blocks_swig4.probe_signal_vf_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(probe_signal_vf_sptr self, long min_output_buffer)
        set_min_output_buffer(probe_signal_vf_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig4.probe_signal_vf_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(probe_signal_vf_sptr self) -> float"""
        return _blocks_swig4.probe_signal_vf_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(probe_signal_vf_sptr self) -> float"""
        return _blocks_swig4.probe_signal_vf_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(probe_signal_vf_sptr self) -> float"""
        return _blocks_swig4.probe_signal_vf_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(probe_signal_vf_sptr self) -> float"""
        return _blocks_swig4.probe_signal_vf_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(probe_signal_vf_sptr self) -> float"""
        return _blocks_swig4.probe_signal_vf_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(probe_signal_vf_sptr self) -> float"""
        return _blocks_swig4.probe_signal_vf_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(probe_signal_vf_sptr self) -> float"""
        return _blocks_swig4.probe_signal_vf_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(probe_signal_vf_sptr self) -> float"""
        return _blocks_swig4.probe_signal_vf_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(probe_signal_vf_sptr self) -> float"""
        return _blocks_swig4.probe_signal_vf_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(probe_signal_vf_sptr self) -> float"""
        return _blocks_swig4.probe_signal_vf_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(probe_signal_vf_sptr self) -> float"""
        return _blocks_swig4.probe_signal_vf_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(probe_signal_vf_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig4.probe_signal_vf_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(probe_signal_vf_sptr self)"""
        return _blocks_swig4.probe_signal_vf_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(probe_signal_vf_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig4.probe_signal_vf_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(probe_signal_vf_sptr self) -> int"""
        return _blocks_swig4.probe_signal_vf_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(probe_signal_vf_sptr self) -> int"""
        return _blocks_swig4.probe_signal_vf_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(probe_signal_vf_sptr self, int priority) -> int"""
        return _blocks_swig4.probe_signal_vf_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(probe_signal_vf_sptr self) -> std::string"""
        return _blocks_swig4.probe_signal_vf_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(probe_signal_vf_sptr self) -> std::string"""
        return _blocks_swig4.probe_signal_vf_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(probe_signal_vf_sptr self) -> io_signature_sptr"""
        return _blocks_swig4.probe_signal_vf_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(probe_signal_vf_sptr self) -> io_signature_sptr"""
        return _blocks_swig4.probe_signal_vf_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(probe_signal_vf_sptr self) -> long"""
        return _blocks_swig4.probe_signal_vf_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(probe_signal_vf_sptr self) -> basic_block_sptr"""
        return _blocks_swig4.probe_signal_vf_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(probe_signal_vf_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig4.probe_signal_vf_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(probe_signal_vf_sptr self) -> std::string"""
        return _blocks_swig4.probe_signal_vf_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(probe_signal_vf_sptr self, std::string name)"""
        return _blocks_swig4.probe_signal_vf_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(probe_signal_vf_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig4.probe_signal_vf_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(probe_signal_vf_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig4.probe_signal_vf_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(probe_signal_vf_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig4.probe_signal_vf_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(probe_signal_vf_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig4.probe_signal_vf_sptr_message_subscribers(self, which_port)

# Register probe_signal_vf_sptr in _blocks_swig4:
_blocks_swig4.probe_signal_vf_sptr_swigregister(probe_signal_vf_sptr)


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

class probe_signal_vc(object):
    r"""Proxy of C++ gr::blocks::probe_signal_v< 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

    @staticmethod
    def make(size: "size_t") -> "gr::blocks::probe_signal_v< std::complex< float > >::sptr":
        r"""make(size_t size) -> probe_signal_vc_sptr"""
        return _blocks_swig4.probe_signal_vc_make(size)

    def level(self) -> "std::vector< std::complex< float >,std::allocator< std::complex< float > > >":
        r"""level(probe_signal_vc self) -> pmt_vector_cfloat"""
        return _blocks_swig4.probe_signal_vc_level(self)
    __swig_destroy__ = _blocks_swig4.delete_probe_signal_vc

# Register probe_signal_vc in _blocks_swig4:
_blocks_swig4.probe_signal_vc_swigregister(probe_signal_vc)

def probe_signal_vc_make(size: "size_t") -> "gr::blocks::probe_signal_v< std::complex< float > >::sptr":
    r"""probe_signal_vc_make(size_t size) -> probe_signal_vc_sptr"""
    return _blocks_swig4.probe_signal_vc_make(size)

class probe_signal_vc_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::blocks::probe_signal_v< 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__(probe_signal_vc_sptr self) -> probe_signal_vc_sptr
        __init__(probe_signal_vc_sptr self, probe_signal_vc p) -> probe_signal_vc_sptr
        """
        _blocks_swig4.probe_signal_vc_sptr_swiginit(self, _blocks_swig4.new_probe_signal_vc_sptr(*args))

    def __deref__(self) -> "gr::blocks::probe_signal_v< gr_complex > *":
        r"""__deref__(probe_signal_vc_sptr self) -> probe_signal_vc"""
        return _blocks_swig4.probe_signal_vc_sptr___deref__(self)
    __swig_destroy__ = _blocks_swig4.delete_probe_signal_vc_sptr

    def make(self, size: "size_t") -> "gr::blocks::probe_signal_v< std::complex< float > >::sptr":
        r"""make(probe_signal_vc_sptr self, size_t size) -> probe_signal_vc_sptr"""
        return _blocks_swig4.probe_signal_vc_sptr_make(self, size)

    def level(self) -> "std::vector< std::complex< float >,std::allocator< std::complex< float > > >":
        r"""level(probe_signal_vc_sptr self) -> pmt_vector_cfloat"""
        return _blocks_swig4.probe_signal_vc_sptr_level(self)

    def history(self) -> "unsigned int":
        r"""history(probe_signal_vc_sptr self) -> unsigned int"""
        return _blocks_swig4.probe_signal_vc_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(probe_signal_vc_sptr self, int which, int delay)
        declare_sample_delay(probe_signal_vc_sptr self, unsigned int delay)
        """
        return _blocks_swig4.probe_signal_vc_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(probe_signal_vc_sptr self, int which) -> unsigned int"""
        return _blocks_swig4.probe_signal_vc_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(probe_signal_vc_sptr self, int multiple)"""
        return _blocks_swig4.probe_signal_vc_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(probe_signal_vc_sptr self) -> int"""
        return _blocks_swig4.probe_signal_vc_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(probe_signal_vc_sptr self) -> double"""
        return _blocks_swig4.probe_signal_vc_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(probe_signal_vc_sptr self) -> uint64_t"""
        return _blocks_swig4.probe_signal_vc_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(probe_signal_vc_sptr self) -> uint64_t"""
        return _blocks_swig4.probe_signal_vc_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(probe_signal_vc_sptr self) -> bool"""
        return _blocks_swig4.probe_signal_vc_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(probe_signal_vc_sptr self) -> bool"""
        return _blocks_swig4.probe_signal_vc_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(probe_signal_vc_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig4.probe_signal_vc_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(probe_signal_vc_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig4.probe_signal_vc_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(probe_signal_vc_sptr self, std::string level)"""
        return _blocks_swig4.probe_signal_vc_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(probe_signal_vc_sptr self) -> std::string"""
        return _blocks_swig4.probe_signal_vc_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(probe_signal_vc_sptr self) -> int"""
        return _blocks_swig4.probe_signal_vc_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(probe_signal_vc_sptr self, int m)"""
        return _blocks_swig4.probe_signal_vc_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(probe_signal_vc_sptr self)"""
        return _blocks_swig4.probe_signal_vc_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(probe_signal_vc_sptr self) -> bool"""
        return _blocks_swig4.probe_signal_vc_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(probe_signal_vc_sptr self, int m)"""
        return _blocks_swig4.probe_signal_vc_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(probe_signal_vc_sptr self) -> int"""
        return _blocks_swig4.probe_signal_vc_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(probe_signal_vc_sptr self, int i) -> long"""
        return _blocks_swig4.probe_signal_vc_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(probe_signal_vc_sptr self, long max_output_buffer)
        set_max_output_buffer(probe_signal_vc_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig4.probe_signal_vc_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(probe_signal_vc_sptr self, int i) -> long"""
        return _blocks_swig4.probe_signal_vc_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(probe_signal_vc_sptr self, long min_output_buffer)
        set_min_output_buffer(probe_signal_vc_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig4.probe_signal_vc_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(probe_signal_vc_sptr self) -> float"""
        return _blocks_swig4.probe_signal_vc_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(probe_signal_vc_sptr self) -> float"""
        return _blocks_swig4.probe_signal_vc_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(probe_signal_vc_sptr self) -> float"""
        return _blocks_swig4.probe_signal_vc_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(probe_signal_vc_sptr self) -> float"""
        return _blocks_swig4.probe_signal_vc_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(probe_signal_vc_sptr self) -> float"""
        return _blocks_swig4.probe_signal_vc_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(probe_signal_vc_sptr self) -> float"""
        return _blocks_swig4.probe_signal_vc_sptr_pc_nproduced_var(self)

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

    def pc_work_time(self) -> "float":
        r"""pc_work_time(probe_signal_vc_sptr self) -> float"""
        return _blocks_swig4.probe_signal_vc_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(probe_signal_vc_sptr self) -> float"""
        return _blocks_swig4.probe_signal_vc_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(probe_signal_vc_sptr self) -> float"""
        return _blocks_swig4.probe_signal_vc_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(probe_signal_vc_sptr self) -> float"""
        return _blocks_swig4.probe_signal_vc_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(probe_signal_vc_sptr self) -> float"""
        return _blocks_swig4.probe_signal_vc_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(probe_signal_vc_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig4.probe_signal_vc_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(probe_signal_vc_sptr self)"""
        return _blocks_swig4.probe_signal_vc_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(probe_signal_vc_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig4.probe_signal_vc_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(probe_signal_vc_sptr self) -> int"""
        return _blocks_swig4.probe_signal_vc_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(probe_signal_vc_sptr self) -> int"""
        return _blocks_swig4.probe_signal_vc_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(probe_signal_vc_sptr self, int priority) -> int"""
        return _blocks_swig4.probe_signal_vc_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(probe_signal_vc_sptr self) -> std::string"""
        return _blocks_swig4.probe_signal_vc_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(probe_signal_vc_sptr self) -> std::string"""
        return _blocks_swig4.probe_signal_vc_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(probe_signal_vc_sptr self) -> io_signature_sptr"""
        return _blocks_swig4.probe_signal_vc_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(probe_signal_vc_sptr self) -> io_signature_sptr"""
        return _blocks_swig4.probe_signal_vc_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(probe_signal_vc_sptr self) -> long"""
        return _blocks_swig4.probe_signal_vc_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(probe_signal_vc_sptr self) -> basic_block_sptr"""
        return _blocks_swig4.probe_signal_vc_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(probe_signal_vc_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig4.probe_signal_vc_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(probe_signal_vc_sptr self) -> std::string"""
        return _blocks_swig4.probe_signal_vc_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(probe_signal_vc_sptr self, std::string name)"""
        return _blocks_swig4.probe_signal_vc_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(probe_signal_vc_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _blocks_swig4.probe_signal_vc_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(probe_signal_vc_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig4.probe_signal_vc_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(probe_signal_vc_sptr self) -> swig_pmt_ptr"""
        return _blocks_swig4.probe_signal_vc_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(probe_signal_vc_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _blocks_swig4.probe_signal_vc_sptr_message_subscribers(self, which_port)

# Register probe_signal_vc_sptr in _blocks_swig4:
_blocks_swig4.probe_signal_vc_sptr_swigregister(probe_signal_vc_sptr)


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



