signature stringlengths 8 3.44k | body stringlengths 0 1.41M | docstring stringlengths 1 122k | id stringlengths 5 17 |
|---|---|---|---|
def _get_rx_bytes_cnt(self): | return self.__rx_bytes_cnt<EOL> | Getter method for rx_bytes_cnt, mapped from YANG variable /cpu_interface_state/host_stats/rx_bytes_cnt (uint64)
YANG Description: Rx bytes counter | f336364:c0:m27 |
def _set_rx_bytes_cnt(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__rx_bytes_cnt = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rx_bytes_cnt, mapped from YANG variable /cpu_interface_state/host_stats/rx_bytes_cnt (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_rx_bytes_cnt is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rx_bytes_cnt() directly.
YANG Description: Rx bytes counter | f336364:c0:m28 |
def _get_rx_errors_cnt(self): | return self.__rx_errors_cnt<EOL> | Getter method for rx_errors_cnt, mapped from YANG variable /cpu_interface_state/host_stats/rx_errors_cnt (uint64)
YANG Description: Rx errors counter | f336364:c0:m30 |
def _set_rx_errors_cnt(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__rx_errors_cnt = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rx_errors_cnt, mapped from YANG variable /cpu_interface_state/host_stats/rx_errors_cnt (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_rx_errors_cnt is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rx_errors_cnt() directly.
YANG Description: Rx errors counter | f336364:c0:m31 |
def _get_rx_drop_cnt(self): | return self.__rx_drop_cnt<EOL> | Getter method for rx_drop_cnt, mapped from YANG variable /cpu_interface_state/host_stats/rx_drop_cnt (uint64)
YANG Description: Rx drop counter | f336364:c0:m33 |
def _set_rx_drop_cnt(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__rx_drop_cnt = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rx_drop_cnt, mapped from YANG variable /cpu_interface_state/host_stats/rx_drop_cnt (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_rx_drop_cnt is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rx_drop_cnt() directly.
YANG Description: Rx drop counter | f336364:c0:m34 |
def _get_rx_overrun_error_cnt(self): | return self.__rx_overrun_error_cnt<EOL> | Getter method for rx_overrun_error_cnt, mapped from YANG variable /cpu_interface_state/host_stats/rx_overrun_error_cnt (uint64)
YANG Description: Rx overrun error counter | f336364:c0:m36 |
def _set_rx_overrun_error_cnt(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__rx_overrun_error_cnt = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rx_overrun_error_cnt, mapped from YANG variable /cpu_interface_state/host_stats/rx_overrun_error_cnt (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_rx_overrun_error_cnt is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rx_overrun_error_cnt() directly.
YANG Description: Rx overrun error counter | f336364:c0:m37 |
def _get_rx_frame_error_cnt(self): | return self.__rx_frame_error_cnt<EOL> | Getter method for rx_frame_error_cnt, mapped from YANG variable /cpu_interface_state/host_stats/rx_frame_error_cnt (uint64)
YANG Description: Rx frame error counter | f336364:c0:m39 |
def _set_rx_frame_error_cnt(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__rx_frame_error_cnt = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rx_frame_error_cnt, mapped from YANG variable /cpu_interface_state/host_stats/rx_frame_error_cnt (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_rx_frame_error_cnt is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rx_frame_error_cnt() directly.
YANG Description: Rx frame error counter | f336364:c0:m40 |
def _get_tx_aborted_error_cnt(self): | return self.__tx_aborted_error_cnt<EOL> | Getter method for tx_aborted_error_cnt, mapped from YANG variable /cpu_interface_state/host_stats/tx_aborted_error_cnt (uint64)
YANG Description: Tx aborted error counter | f336364:c0:m42 |
def _set_tx_aborted_error_cnt(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__tx_aborted_error_cnt = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for tx_aborted_error_cnt, mapped from YANG variable /cpu_interface_state/host_stats/tx_aborted_error_cnt (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_tx_aborted_error_cnt is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tx_aborted_error_cnt() directly.
YANG Description: Tx aborted error counter | f336364:c0:m43 |
def _get_tx_fifo_error_cnt(self): | return self.__tx_fifo_error_cnt<EOL> | Getter method for tx_fifo_error_cnt, mapped from YANG variable /cpu_interface_state/host_stats/tx_fifo_error_cnt (uint64)
YANG Description: Tx fifo error counter | f336364:c0:m45 |
def _set_tx_fifo_error_cnt(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__tx_fifo_error_cnt = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for tx_fifo_error_cnt, mapped from YANG variable /cpu_interface_state/host_stats/tx_fifo_error_cnt (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_tx_fifo_error_cnt is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tx_fifo_error_cnt() directly.
YANG Description: Tx fifo error counter | f336364:c0:m46 |
def _get_tx_timeout_cnt(self): | return self.__tx_timeout_cnt<EOL> | Getter method for tx_timeout_cnt, mapped from YANG variable /cpu_interface_state/host_stats/tx_timeout_cnt (uint64)
YANG Description: Tx timeout counter | f336364:c0:m48 |
def _set_tx_timeout_cnt(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__tx_timeout_cnt = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for tx_timeout_cnt, mapped from YANG variable /cpu_interface_state/host_stats/tx_timeout_cnt (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_tx_timeout_cnt is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tx_timeout_cnt() directly.
YANG Description: Tx timeout counter | f336364:c0:m49 |
def _get_tx_flow_control_xon_cnt(self): | return self.__tx_flow_control_xon_cnt<EOL> | Getter method for tx_flow_control_xon_cnt, mapped from YANG variable /cpu_interface_state/host_stats/tx_flow_control_xon_cnt (uint64)
YANG Description: Tx flow control xon counter | f336364:c0:m51 |
def _set_tx_flow_control_xon_cnt(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__tx_flow_control_xon_cnt = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for tx_flow_control_xon_cnt, mapped from YANG variable /cpu_interface_state/host_stats/tx_flow_control_xon_cnt (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_tx_flow_control_xon_cnt is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tx_flow_control_xon_cnt() directly.
YANG Description: Tx flow control xon counter | f336364:c0:m52 |
def _get_tx_flow_control_xoff_cnt(self): | return self.__tx_flow_control_xoff_cnt<EOL> | Getter method for tx_flow_control_xoff_cnt, mapped from YANG variable /cpu_interface_state/host_stats/tx_flow_control_xoff_cnt (uint64)
YANG Description: Tx flow control xoff counter | f336364:c0:m54 |
def _set_tx_flow_control_xoff_cnt(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__tx_flow_control_xoff_cnt = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for tx_flow_control_xoff_cnt, mapped from YANG variable /cpu_interface_state/host_stats/tx_flow_control_xoff_cnt (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_tx_flow_control_xoff_cnt is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tx_flow_control_xoff_cnt() directly.
YANG Description: Tx flow control xoff counter | f336364:c0:m55 |
def _get_tx_pkts_64bytes_cnt(self): | return self.__tx_pkts_64bytes_cnt<EOL> | Getter method for tx_pkts_64bytes_cnt, mapped from YANG variable /cpu_interface_state/host_stats/tx_pkts_64bytes_cnt (uint64)
YANG Description: Tx packets 64 bytes counter | f336364:c0:m57 |
def _set_tx_pkts_64bytes_cnt(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__tx_pkts_64bytes_cnt = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for tx_pkts_64bytes_cnt, mapped from YANG variable /cpu_interface_state/host_stats/tx_pkts_64bytes_cnt (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_tx_pkts_64bytes_cnt is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tx_pkts_64bytes_cnt() directly.
YANG Description: Tx packets 64 bytes counter | f336364:c0:m58 |
def _get_tx_pkts_64_127bytes_cnt(self): | return self.__tx_pkts_64_127bytes_cnt<EOL> | Getter method for tx_pkts_64_127bytes_cnt, mapped from YANG variable /cpu_interface_state/host_stats/tx_pkts_64_127bytes_cnt (uint64)
YANG Description: Tx packets 64 to 127 bytes counter | f336364:c0:m60 |
def _set_tx_pkts_64_127bytes_cnt(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__tx_pkts_64_127bytes_cnt = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for tx_pkts_64_127bytes_cnt, mapped from YANG variable /cpu_interface_state/host_stats/tx_pkts_64_127bytes_cnt (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_tx_pkts_64_127bytes_cnt is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tx_pkts_64_127bytes_cnt() directly.
YANG Description: Tx packets 64 to 127 bytes counter | f336364:c0:m61 |
def _get_tx_pkts_128_255bytes_cnt(self): | return self.__tx_pkts_128_255bytes_cnt<EOL> | Getter method for tx_pkts_128_255bytes_cnt, mapped from YANG variable /cpu_interface_state/host_stats/tx_pkts_128_255bytes_cnt (uint64)
YANG Description: Tx packets 128 to 255 bytes counter | f336364:c0:m63 |
def _set_tx_pkts_128_255bytes_cnt(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__tx_pkts_128_255bytes_cnt = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for tx_pkts_128_255bytes_cnt, mapped from YANG variable /cpu_interface_state/host_stats/tx_pkts_128_255bytes_cnt (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_tx_pkts_128_255bytes_cnt is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tx_pkts_128_255bytes_cnt() directly.
YANG Description: Tx packets 128 to 255 bytes counter | f336364:c0:m64 |
def _get_tx_pkts_256_511bytes_cnt(self): | return self.__tx_pkts_256_511bytes_cnt<EOL> | Getter method for tx_pkts_256_511bytes_cnt, mapped from YANG variable /cpu_interface_state/host_stats/tx_pkts_256_511bytes_cnt (uint64)
YANG Description: Tx packets 256 to 511 bytes counter | f336364:c0:m66 |
def _set_tx_pkts_256_511bytes_cnt(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__tx_pkts_256_511bytes_cnt = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for tx_pkts_256_511bytes_cnt, mapped from YANG variable /cpu_interface_state/host_stats/tx_pkts_256_511bytes_cnt (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_tx_pkts_256_511bytes_cnt is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tx_pkts_256_511bytes_cnt() directly.
YANG Description: Tx packets 256 to 511 bytes counter | f336364:c0:m67 |
def _get_tx_pkts_512_1023bytes_cnt(self): | return self.__tx_pkts_512_1023bytes_cnt<EOL> | Getter method for tx_pkts_512_1023bytes_cnt, mapped from YANG variable /cpu_interface_state/host_stats/tx_pkts_512_1023bytes_cnt (uint64)
YANG Description: Tx packets 512 to 1023 bytes counter | f336364:c0:m69 |
def _set_tx_pkts_512_1023bytes_cnt(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__tx_pkts_512_1023bytes_cnt = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for tx_pkts_512_1023bytes_cnt, mapped from YANG variable /cpu_interface_state/host_stats/tx_pkts_512_1023bytes_cnt (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_tx_pkts_512_1023bytes_cnt is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tx_pkts_512_1023bytes_cnt() directly.
YANG Description: Tx packets 512 to 1023 bytes counter | f336364:c0:m70 |
def _get_tx_pkts_1024bytes_max_cnt(self): | return self.__tx_pkts_1024bytes_max_cnt<EOL> | Getter method for tx_pkts_1024bytes_max_cnt, mapped from YANG variable /cpu_interface_state/host_stats/tx_pkts_1024bytes_max_cnt (uint64)
YANG Description: Tx packets 1024 to Max bytes counter | f336364:c0:m72 |
def _set_tx_pkts_1024bytes_max_cnt(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__tx_pkts_1024bytes_max_cnt = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for tx_pkts_1024bytes_max_cnt, mapped from YANG variable /cpu_interface_state/host_stats/tx_pkts_1024bytes_max_cnt (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_tx_pkts_1024bytes_max_cnt is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tx_pkts_1024bytes_max_cnt() directly.
YANG Description: Tx packets 1024 to Max bytes counter | f336364:c0:m73 |
def _get_tx_bcast_pkts_cnt(self): | return self.__tx_bcast_pkts_cnt<EOL> | Getter method for tx_bcast_pkts_cnt, mapped from YANG variable /cpu_interface_state/host_stats/tx_bcast_pkts_cnt (uint64)
YANG Description: Tx drop counter | f336364:c0:m75 |
def _set_tx_bcast_pkts_cnt(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__tx_bcast_pkts_cnt = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for tx_bcast_pkts_cnt, mapped from YANG variable /cpu_interface_state/host_stats/tx_bcast_pkts_cnt (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_tx_bcast_pkts_cnt is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tx_bcast_pkts_cnt() directly.
YANG Description: Tx drop counter | f336364:c0:m76 |
def _get_tx_mcast_pkts_cnt(self): | return self.__tx_mcast_pkts_cnt<EOL> | Getter method for tx_mcast_pkts_cnt, mapped from YANG variable /cpu_interface_state/host_stats/tx_mcast_pkts_cnt (uint64)
YANG Description: Tx drop counter | f336364:c0:m78 |
def _set_tx_mcast_pkts_cnt(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__tx_mcast_pkts_cnt = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for tx_mcast_pkts_cnt, mapped from YANG variable /cpu_interface_state/host_stats/tx_mcast_pkts_cnt (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_tx_mcast_pkts_cnt is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tx_mcast_pkts_cnt() directly.
YANG Description: Tx drop counter | f336364:c0:m79 |
def _get_rx_crc_error_cnt(self): | return self.__rx_crc_error_cnt<EOL> | Getter method for rx_crc_error_cnt, mapped from YANG variable /cpu_interface_state/host_stats/rx_crc_error_cnt (uint64)
YANG Description: Rx crc error counter | f336364:c0:m81 |
def _set_rx_crc_error_cnt(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__rx_crc_error_cnt = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rx_crc_error_cnt, mapped from YANG variable /cpu_interface_state/host_stats/rx_crc_error_cnt (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_rx_crc_error_cnt is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rx_crc_error_cnt() directly.
YANG Description: Rx crc error counter | f336364:c0:m82 |
def _get_rx_fifo_error_cnt(self): | return self.__rx_fifo_error_cnt<EOL> | Getter method for rx_fifo_error_cnt, mapped from YANG variable /cpu_interface_state/host_stats/rx_fifo_error_cnt (uint64)
YANG Description: Rx fifo error counter | f336364:c0:m84 |
def _set_rx_fifo_error_cnt(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__rx_fifo_error_cnt = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rx_fifo_error_cnt, mapped from YANG variable /cpu_interface_state/host_stats/rx_fifo_error_cnt (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_rx_fifo_error_cnt is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rx_fifo_error_cnt() directly.
YANG Description: Rx fifo error counter | f336364:c0:m85 |
def _get_rx_missed_errors_cnt(self): | return self.__rx_missed_errors_cnt<EOL> | Getter method for rx_missed_errors_cnt, mapped from YANG variable /cpu_interface_state/host_stats/rx_missed_errors_cnt (uint64)
YANG Description: Rx missed errors counter | f336364:c0:m87 |
def _set_rx_missed_errors_cnt(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__rx_missed_errors_cnt = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rx_missed_errors_cnt, mapped from YANG variable /cpu_interface_state/host_stats/rx_missed_errors_cnt (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_rx_missed_errors_cnt is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rx_missed_errors_cnt() directly.
YANG Description: Rx missed errors counter | f336364:c0:m88 |
def _get_rx_no_dma_resource_cnt(self): | return self.__rx_no_dma_resource_cnt<EOL> | Getter method for rx_no_dma_resource_cnt, mapped from YANG variable /cpu_interface_state/host_stats/rx_no_dma_resource_cnt (uint64)
YANG Description: Rx no dma resource | f336364:c0:m90 |
def _set_rx_no_dma_resource_cnt(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__rx_no_dma_resource_cnt = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rx_no_dma_resource_cnt, mapped from YANG variable /cpu_interface_state/host_stats/rx_no_dma_resource_cnt (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_rx_no_dma_resource_cnt is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rx_no_dma_resource_cnt() directly.
YANG Description: Rx no dma resource | f336364:c0:m91 |
def _get_rx_flow_control_xon_cnt(self): | return self.__rx_flow_control_xon_cnt<EOL> | Getter method for rx_flow_control_xon_cnt, mapped from YANG variable /cpu_interface_state/host_stats/rx_flow_control_xon_cnt (uint64)
YANG Description: Rx flow control xon counter | f336364:c0:m93 |
def _set_rx_flow_control_xon_cnt(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__rx_flow_control_xon_cnt = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rx_flow_control_xon_cnt, mapped from YANG variable /cpu_interface_state/host_stats/rx_flow_control_xon_cnt (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_rx_flow_control_xon_cnt is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rx_flow_control_xon_cnt() directly.
YANG Description: Rx flow control xon counter | f336364:c0:m94 |
def _get_rx_flow_control_xoff_cnt(self): | return self.__rx_flow_control_xoff_cnt<EOL> | Getter method for rx_flow_control_xoff_cnt, mapped from YANG variable /cpu_interface_state/host_stats/rx_flow_control_xoff_cnt (uint64)
YANG Description: Rx flow control xoff counter | f336364:c0:m96 |
def _set_rx_flow_control_xoff_cnt(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__rx_flow_control_xoff_cnt = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rx_flow_control_xoff_cnt, mapped from YANG variable /cpu_interface_state/host_stats/rx_flow_control_xoff_cnt (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_rx_flow_control_xoff_cnt is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rx_flow_control_xoff_cnt() directly.
YANG Description: Rx flow control xoff counter | f336364:c0:m97 |
def _get_rx_pkts_64bytes_cnt(self): | return self.__rx_pkts_64bytes_cnt<EOL> | Getter method for rx_pkts_64bytes_cnt, mapped from YANG variable /cpu_interface_state/host_stats/rx_pkts_64bytes_cnt (uint64)
YANG Description: Rx packets 64 bytes counter | f336364:c0:m99 |
def _set_rx_pkts_64bytes_cnt(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__rx_pkts_64bytes_cnt = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rx_pkts_64bytes_cnt, mapped from YANG variable /cpu_interface_state/host_stats/rx_pkts_64bytes_cnt (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_rx_pkts_64bytes_cnt is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rx_pkts_64bytes_cnt() directly.
YANG Description: Rx packets 64 bytes counter | f336364:c0:m100 |
def _get_rx_pkts_64_127bytes_cnt(self): | return self.__rx_pkts_64_127bytes_cnt<EOL> | Getter method for rx_pkts_64_127bytes_cnt, mapped from YANG variable /cpu_interface_state/host_stats/rx_pkts_64_127bytes_cnt (uint64)
YANG Description: Rx packets 64 to 127 bytes counter | f336364:c0:m102 |
def _set_rx_pkts_64_127bytes_cnt(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__rx_pkts_64_127bytes_cnt = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rx_pkts_64_127bytes_cnt, mapped from YANG variable /cpu_interface_state/host_stats/rx_pkts_64_127bytes_cnt (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_rx_pkts_64_127bytes_cnt is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rx_pkts_64_127bytes_cnt() directly.
YANG Description: Rx packets 64 to 127 bytes counter | f336364:c0:m103 |
def _get_rx_pkts_128_255bytes_cnt(self): | return self.__rx_pkts_128_255bytes_cnt<EOL> | Getter method for rx_pkts_128_255bytes_cnt, mapped from YANG variable /cpu_interface_state/host_stats/rx_pkts_128_255bytes_cnt (uint64)
YANG Description: Rx packets 128 to 255 bytes counter | f336364:c0:m105 |
def _set_rx_pkts_128_255bytes_cnt(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__rx_pkts_128_255bytes_cnt = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rx_pkts_128_255bytes_cnt, mapped from YANG variable /cpu_interface_state/host_stats/rx_pkts_128_255bytes_cnt (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_rx_pkts_128_255bytes_cnt is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rx_pkts_128_255bytes_cnt() directly.
YANG Description: Rx packets 128 to 255 bytes counter | f336364:c0:m106 |
def _get_rx_pkts_256_511bytes_cnt(self): | return self.__rx_pkts_256_511bytes_cnt<EOL> | Getter method for rx_pkts_256_511bytes_cnt, mapped from YANG variable /cpu_interface_state/host_stats/rx_pkts_256_511bytes_cnt (uint64)
YANG Description: Rx packets 256 to 511 bytes counter | f336364:c0:m108 |
def _set_rx_pkts_256_511bytes_cnt(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__rx_pkts_256_511bytes_cnt = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rx_pkts_256_511bytes_cnt, mapped from YANG variable /cpu_interface_state/host_stats/rx_pkts_256_511bytes_cnt (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_rx_pkts_256_511bytes_cnt is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rx_pkts_256_511bytes_cnt() directly.
YANG Description: Rx packets 256 to 511 bytes counter | f336364:c0:m109 |
def _get_rx_pkts_512_1023bytes_cnt(self): | return self.__rx_pkts_512_1023bytes_cnt<EOL> | Getter method for rx_pkts_512_1023bytes_cnt, mapped from YANG variable /cpu_interface_state/host_stats/rx_pkts_512_1023bytes_cnt (uint64)
YANG Description: Rx packets 512 to 1023 bytes counter | f336364:c0:m111 |
def _set_rx_pkts_512_1023bytes_cnt(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__rx_pkts_512_1023bytes_cnt = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rx_pkts_512_1023bytes_cnt, mapped from YANG variable /cpu_interface_state/host_stats/rx_pkts_512_1023bytes_cnt (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_rx_pkts_512_1023bytes_cnt is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rx_pkts_512_1023bytes_cnt() directly.
YANG Description: Rx packets 512 to 1023 bytes counter | f336364:c0:m112 |
def _get_rx_pkts_1024bytes_max_cnt(self): | return self.__rx_pkts_1024bytes_max_cnt<EOL> | Getter method for rx_pkts_1024bytes_max_cnt, mapped from YANG variable /cpu_interface_state/host_stats/rx_pkts_1024bytes_max_cnt (uint64)
YANG Description: Rx packets 1024 to Max bytes counter | f336364:c0:m114 |
def _set_rx_pkts_1024bytes_max_cnt(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__rx_pkts_1024bytes_max_cnt = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rx_pkts_1024bytes_max_cnt, mapped from YANG variable /cpu_interface_state/host_stats/rx_pkts_1024bytes_max_cnt (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_rx_pkts_1024bytes_max_cnt is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rx_pkts_1024bytes_max_cnt() directly.
YANG Description: Rx packets 1024 to Max bytes counter | f336364:c0:m115 |
def _get_rx_good_pkts_cnt(self): | return self.__rx_good_pkts_cnt<EOL> | Getter method for rx_good_pkts_cnt, mapped from YANG variable /cpu_interface_state/host_stats/rx_good_pkts_cnt (uint64)
YANG Description: Rx good pkts counter | f336364:c0:m117 |
def _set_rx_good_pkts_cnt(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__rx_good_pkts_cnt = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rx_good_pkts_cnt, mapped from YANG variable /cpu_interface_state/host_stats/rx_good_pkts_cnt (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_rx_good_pkts_cnt is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rx_good_pkts_cnt() directly.
YANG Description: Rx good pkts counter | f336364:c0:m118 |
def _get_rx_bcast_pkts_cnt(self): | return self.__rx_bcast_pkts_cnt<EOL> | Getter method for rx_bcast_pkts_cnt, mapped from YANG variable /cpu_interface_state/host_stats/rx_bcast_pkts_cnt (uint64)
YANG Description: Rx broadcast pkts counter | f336364:c0:m120 |
def _set_rx_bcast_pkts_cnt(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__rx_bcast_pkts_cnt = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rx_bcast_pkts_cnt, mapped from YANG variable /cpu_interface_state/host_stats/rx_bcast_pkts_cnt (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_rx_bcast_pkts_cnt is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rx_bcast_pkts_cnt() directly.
YANG Description: Rx broadcast pkts counter | f336364:c0:m121 |
def _get_rx_mcast_pkts_cnt(self): | return self.__rx_mcast_pkts_cnt<EOL> | Getter method for rx_mcast_pkts_cnt, mapped from YANG variable /cpu_interface_state/host_stats/rx_mcast_pkts_cnt (uint64)
YANG Description: Rx multicast counter | f336364:c0:m123 |
def _set_rx_mcast_pkts_cnt(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__rx_mcast_pkts_cnt = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rx_mcast_pkts_cnt, mapped from YANG variable /cpu_interface_state/host_stats/rx_mcast_pkts_cnt (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_rx_mcast_pkts_cnt is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rx_mcast_pkts_cnt() directly.
YANG Description: Rx multicast counter | f336364:c0:m124 |
def _get_prefix_list_name(self): | return self.__prefix_list_name<EOL> | Getter method for prefix_list_name, mapped from YANG variable /igmp_snooping_state/multicast_ssm_mapping/ssm_maps/prefix_list_name (string)
YANG Description: ssm map prefix list name | f336365:c0:m3 |
def _set_prefix_list_name(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__prefix_list_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for prefix_list_name, mapped from YANG variable /igmp_snooping_state/multicast_ssm_mapping/ssm_maps/prefix_list_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_prefix_list_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_prefix_list_name() directly.
YANG Description: ssm map prefix list name | f336365:c0:m4 |
def _get_src_ip_addr(self): | return self.__src_ip_addr<EOL> | Getter method for src_ip_addr, mapped from YANG variable /igmp_snooping_state/multicast_ssm_mapping/ssm_maps/src_ip_addr (inet:ipv4-address)
YANG Description: ipv4 source address | f336365:c0:m6 |
def _set_src_ip_addr(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>'}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__src_ip_addr = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for src_ip_addr, mapped from YANG variable /igmp_snooping_state/multicast_ssm_mapping/ssm_maps/src_ip_addr (inet:ipv4-address)
If this variable is read-only (config: false) in the
source YANG file, then _set_src_ip_addr is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_src_ip_addr() directly.
YANG Description: ipv4 source address | f336365:c0:m7 |
def _get_group_addr(self): | return self.__group_addr<EOL> | Getter method for group_addr, mapped from YANG variable /igmp_snooping_state/igmp_groups/group_addr (inet:ipv4-address)
YANG Description: Multicast Group Address | f336366:c0:m3 |
def _set_group_addr(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>'}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__group_addr = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for group_addr, mapped from YANG variable /igmp_snooping_state/igmp_groups/group_addr (inet:ipv4-address)
If this variable is read-only (config: false) in the
source YANG file, then _set_group_addr is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_group_addr() directly.
YANG Description: Multicast Group Address | f336366:c0:m4 |
def _get_interface_name(self): | return self.__interface_name<EOL> | Getter method for interface_name, mapped from YANG variable /igmp_snooping_state/igmp_groups/interface_name (string)
YANG Description: Igmp interface name | f336366:c0:m6 |
def _set_interface_name(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__interface_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for interface_name, mapped from YANG variable /igmp_snooping_state/igmp_groups/interface_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_interface_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_interface_name() directly.
YANG Description: Igmp interface name | f336366:c0:m7 |
def _get_igmp_groups(self): | return self.__igmp_groups<EOL> | Getter method for igmp_groups, mapped from YANG variable /igmp_snooping_state/igmp_groups/igmp_groups (list) | f336366:c0:m9 |
def _set_igmp_groups(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGListType("<STR_LIT>",igmp_groups_.igmp_groups, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT>', extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>'}}), is_container='<STR_LIT:list>', yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:list>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__igmp_groups = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for igmp_groups, mapped from YANG variable /igmp_snooping_state/igmp_groups/igmp_groups (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_igmp_groups is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_igmp_groups() directly. | f336366:c0:m10 |
def _get_ipv4_addr(self): | return self.__ipv4_addr<EOL> | Getter method for ipv4_addr, mapped from YANG variable /igmp_snooping_state/igmp_groups/igmp_groups/igmpv3_sources/excl_src_ip/ipv4_addr (uint32)
YANG Description: A Simple UI32 MO for string ip address in integer format | f336367:c0:m3 |
def _set_ipv4_addr(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__ipv4_addr = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ipv4_addr, mapped from YANG variable /igmp_snooping_state/igmp_groups/igmp_groups/igmpv3_sources/excl_src_ip/ipv4_addr (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_ipv4_addr is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ipv4_addr() directly.
YANG Description: A Simple UI32 MO for string ip address in integer format | f336367:c0:m4 |
def _get_ipv4_addr(self): | return self.__ipv4_addr<EOL> | Getter method for ipv4_addr, mapped from YANG variable /igmp_snooping_state/igmp_groups/igmp_groups/igmpv3_sources/incl_src_ip/ipv4_addr (uint32)
YANG Description: A Simple UI32 MO for string ip address in integer format | f336368:c0:m3 |
def _set_ipv4_addr(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__ipv4_addr = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ipv4_addr, mapped from YANG variable /igmp_snooping_state/igmp_groups/igmp_groups/igmpv3_sources/incl_src_ip/ipv4_addr (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_ipv4_addr is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ipv4_addr() directly.
YANG Description: A Simple UI32 MO for string ip address in integer format | f336368:c0:m4 |
def _get_group_addr(self): | return self.__group_addr<EOL> | Getter method for group_addr, mapped from YANG variable /igmp_snooping_state/igmp_groups/igmp_groups/group_addr (uint32)
YANG Description: group ip address | f336369:c0:m3 |
def _set_group_addr(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__group_addr = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for group_addr, mapped from YANG variable /igmp_snooping_state/igmp_groups/igmp_groups/group_addr (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_group_addr is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_group_addr() directly.
YANG Description: group ip address | f336369:c0:m4 |
def _get_interface_name(self): | return self.__interface_name<EOL> | Getter method for interface_name, mapped from YANG variable /igmp_snooping_state/igmp_groups/igmp_groups/interface_name (string)
YANG Description: Igmp interface name hosting a group | f336369:c0:m6 |
def _set_interface_name(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__interface_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for interface_name, mapped from YANG variable /igmp_snooping_state/igmp_groups/igmp_groups/interface_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_interface_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_interface_name() directly.
YANG Description: Igmp interface name hosting a group | f336369:c0:m7 |
def _get_uptime(self): | return self.__uptime<EOL> | Getter method for uptime, mapped from YANG variable /igmp_snooping_state/igmp_groups/igmp_groups/uptime (string)
YANG Description: group up time | f336369:c0:m9 |
def _set_uptime(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__uptime = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for uptime, mapped from YANG variable /igmp_snooping_state/igmp_groups/igmp_groups/uptime (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_uptime is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_uptime() directly.
YANG Description: group up time | f336369:c0:m10 |
def _get_expiry_time(self): | return self.__expiry_time<EOL> | Getter method for expiry_time, mapped from YANG variable /igmp_snooping_state/igmp_groups/igmp_groups/expiry_time (string)
YANG Description: group expiry time | f336369:c0:m12 |
def _set_expiry_time(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__expiry_time = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for expiry_time, mapped from YANG variable /igmp_snooping_state/igmp_groups/igmp_groups/expiry_time (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_expiry_time is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_expiry_time() directly.
YANG Description: group expiry time | f336369:c0:m13 |
def _get_last_reporter(self): | return self.__last_reporter<EOL> | Getter method for last_reporter, mapped from YANG variable /igmp_snooping_state/igmp_groups/igmp_groups/last_reporter (uint32)
YANG Description: last reporter | f336369:c0:m15 |
def _set_last_reporter(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__last_reporter = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for last_reporter, mapped from YANG variable /igmp_snooping_state/igmp_groups/igmp_groups/last_reporter (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_last_reporter is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_last_reporter() directly.
YANG Description: last reporter | f336369:c0:m16 |
def _get_filter_mode(self): | return self.__filter_mode<EOL> | Getter method for filter_mode, mapped from YANG variable /igmp_snooping_state/igmp_groups/igmp_groups/filter_mode (uint8)
YANG Description: filter mode | f336369:c0:m18 |
def _set_filter_mode(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:8>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__filter_mode = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for filter_mode, mapped from YANG variable /igmp_snooping_state/igmp_groups/igmp_groups/filter_mode (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_filter_mode is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_filter_mode() directly.
YANG Description: filter mode | f336369:c0:m19 |
def _get_member_ship(self): | return self.__member_ship<EOL> | Getter method for member_ship, mapped from YANG variable /igmp_snooping_state/igmp_groups/igmp_groups/member_ship (string)
YANG Description: Group interface member ship | f336369:c0:m21 |
def _set_member_ship(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__member_ship = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for member_ship, mapped from YANG variable /igmp_snooping_state/igmp_groups/igmp_groups/member_ship (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_member_ship is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_member_ship() directly.
YANG Description: Group interface member ship | f336369:c0:m22 |
def _get_igmpv3_sources(self): | return self.__igmpv3_sources<EOL> | Getter method for igmpv3_sources, mapped from YANG variable /igmp_snooping_state/igmp_groups/igmp_groups/igmpv3_sources (list)
YANG Description: Igmp Snooping version 3 include/exclude source list | f336369:c0:m24 |
def _set_igmpv3_sources(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGListType("<STR_LIT>",igmpv3_sources.igmpv3_sources, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT>', extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}), is_container='<STR_LIT:list>', yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:list>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__igmpv3_sources = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for igmpv3_sources, mapped from YANG variable /igmp_snooping_state/igmp_groups/igmp_groups/igmpv3_sources (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_igmpv3_sources is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_igmpv3_sources() directly.
YANG Description: Igmp Snooping version 3 include/exclude source list | f336369:c0:m25 |
def _get_vlan_id(self): | return self.__vlan_id<EOL> | Getter method for vlan_id, mapped from YANG variable /igmp_snooping_state/igmp_snooping_mrouters/vlan_id (uint32)
YANG Description: vlan id | f336370:c0:m3 |
def _set_vlan_id(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__vlan_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vlan_id, mapped from YANG variable /igmp_snooping_state/igmp_snooping_mrouters/vlan_id (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_vlan_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vlan_id() directly.
YANG Description: vlan id | f336370:c0:m4 |
def _get_igmp_snooping_mrouters(self): | return self.__igmp_snooping_mrouters<EOL> | Getter method for igmp_snooping_mrouters, mapped from YANG variable /igmp_snooping_state/igmp_snooping_mrouters/igmp_snooping_mrouters (list)
YANG Description: Igmp snoopig mrouter info | f336370:c0:m6 |
def _set_igmp_snooping_mrouters(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGListType("<STR_LIT>",igmp_snooping_mrouters_.igmp_snooping_mrouters, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT>', extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}), is_container='<STR_LIT:list>', yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:list>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__igmp_snooping_mrouters = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for igmp_snooping_mrouters, mapped from YANG variable /igmp_snooping_state/igmp_snooping_mrouters/igmp_snooping_mrouters (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_igmp_snooping_mrouters is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_igmp_snooping_mrouters() directly.
YANG Description: Igmp snoopig mrouter info | f336370:c0:m7 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.