signature stringlengths 8 3.44k | body stringlengths 0 1.41M | docstring stringlengths 1 122k | id stringlengths 5 17 |
|---|---|---|---|
def _get_tx_bytes_cnt(self): | return self.__tx_bytes_cnt<EOL> | Getter method for tx_bytes_cnt, mapped from YANG variable /cpu_interface_state/gos_stats/tx_bytes_cnt (uint64)
YANG Description: Tx bytes counter | f336362:c0:m9 |
def _set_tx_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.__tx_bytes_cnt = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for tx_bytes_cnt, mapped from YANG variable /cpu_interface_state/gos_stats/tx_bytes_cnt (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_tx_bytes_cnt is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tx_bytes_cnt() directly.
YANG Description: Tx bytes counter | f336362:c0:m10 |
def _get_tx_errors_cnt(self): | return self.__tx_errors_cnt<EOL> | Getter method for tx_errors_cnt, mapped from YANG variable /cpu_interface_state/gos_stats/tx_errors_cnt (uint64)
YANG Description: Tx error counter | f336362:c0:m12 |
def _set_tx_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.__tx_errors_cnt = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for tx_errors_cnt, mapped from YANG variable /cpu_interface_state/gos_stats/tx_errors_cnt (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_tx_errors_cnt is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tx_errors_cnt() directly.
YANG Description: Tx error counter | f336362:c0:m13 |
def _get_tx_drop_cnt(self): | return self.__tx_drop_cnt<EOL> | Getter method for tx_drop_cnt, mapped from YANG variable /cpu_interface_state/gos_stats/tx_drop_cnt (uint64)
YANG Description: Tx drop counter | f336362:c0:m15 |
def _set_tx_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.__tx_drop_cnt = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for tx_drop_cnt, mapped from YANG variable /cpu_interface_state/gos_stats/tx_drop_cnt (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_tx_drop_cnt is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tx_drop_cnt() directly.
YANG Description: Tx drop counter | f336362:c0:m16 |
def _get_tx_overrun_error_cnt(self): | return self.__tx_overrun_error_cnt<EOL> | Getter method for tx_overrun_error_cnt, mapped from YANG variable /cpu_interface_state/gos_stats/tx_overrun_error_cnt (uint64)
YANG Description: Tx overrun error counter | f336362:c0:m18 |
def _set_tx_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.__tx_overrun_error_cnt = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for tx_overrun_error_cnt, mapped from YANG variable /cpu_interface_state/gos_stats/tx_overrun_error_cnt (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_tx_overrun_error_cnt is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tx_overrun_error_cnt() directly.
YANG Description: Tx overrun error counter | f336362:c0:m19 |
def _get_tx_carrier_error_cnt(self): | return self.__tx_carrier_error_cnt<EOL> | Getter method for tx_carrier_error_cnt, mapped from YANG variable /cpu_interface_state/gos_stats/tx_carrier_error_cnt (uint64)
YANG Description: Tx carrier error counter | f336362:c0:m21 |
def _set_tx_carrier_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_carrier_error_cnt = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for tx_carrier_error_cnt, mapped from YANG variable /cpu_interface_state/gos_stats/tx_carrier_error_cnt (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_tx_carrier_error_cnt is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tx_carrier_error_cnt() directly.
YANG Description: Tx carrier error counter | f336362:c0:m22 |
def _get_rx_pkts_cnt(self): | return self.__rx_pkts_cnt<EOL> | Getter method for rx_pkts_cnt, mapped from YANG variable /cpu_interface_state/gos_stats/rx_pkts_cnt (uint64)
YANG Description: Rx packets counter | f336362:c0:m24 |
def _set_rx_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_pkts_cnt = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rx_pkts_cnt, mapped from YANG variable /cpu_interface_state/gos_stats/rx_pkts_cnt (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_rx_pkts_cnt is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rx_pkts_cnt() directly.
YANG Description: Rx packets counter | f336362:c0:m25 |
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/gos_stats/rx_bytes_cnt (uint64)
YANG Description: Rx bytes counter | f336362: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/gos_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 | f336362: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/gos_stats/rx_errors_cnt (uint64)
YANG Description: Rx errors counter | f336362: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/gos_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 | f336362: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/gos_stats/rx_drop_cnt (uint64)
YANG Description: Rx drop counter | f336362: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/gos_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 | f336362: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/gos_stats/rx_overrun_error_cnt (uint64)
YANG Description: Rx overrun error counter | f336362: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/gos_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 | f336362: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/gos_stats/rx_frame_error_cnt (uint64)
YANG Description: Rx frame error counter | f336362: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/gos_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 | f336362: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/gos_stats/tx_aborted_error_cnt (uint64)
YANG Description: Tx aborted error counter | f336362: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/gos_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 | f336362: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/gos_stats/tx_fifo_error_cnt (uint64)
YANG Description: Tx fifo error counter | f336362: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/gos_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 | f336362: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/gos_stats/tx_timeout_cnt (uint64)
YANG Description: Tx timeout counter | f336362: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/gos_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 | f336362: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/gos_stats/tx_flow_control_xon_cnt (uint64)
YANG Description: Tx flow control xon counter | f336362: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/gos_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 | f336362: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/gos_stats/tx_flow_control_xoff_cnt (uint64)
YANG Description: Tx flow control xoff counter | f336362: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/gos_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 | f336362: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/gos_stats/tx_pkts_64bytes_cnt (uint64)
YANG Description: Tx packets 64 bytes counter | f336362: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/gos_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 | f336362: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/gos_stats/tx_pkts_64_127bytes_cnt (uint64)
YANG Description: Tx packets 64 to 127 bytes counter | f336362: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/gos_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 | f336362: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/gos_stats/tx_pkts_128_255bytes_cnt (uint64)
YANG Description: Tx packets 128 to 255 bytes counter | f336362: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/gos_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 | f336362: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/gos_stats/tx_pkts_256_511bytes_cnt (uint64)
YANG Description: Tx packets 256 to 511 bytes counter | f336362: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/gos_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 | f336362: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/gos_stats/tx_pkts_512_1023bytes_cnt (uint64)
YANG Description: Tx packets 512 to 1023 bytes counter | f336362: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/gos_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 | f336362: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/gos_stats/tx_pkts_1024bytes_max_cnt (uint64)
YANG Description: Tx packets 1024 to Max bytes counter | f336362: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/gos_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 | f336362: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/gos_stats/tx_bcast_pkts_cnt (uint64)
YANG Description: Tx drop counter | f336362: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/gos_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 | f336362: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/gos_stats/tx_mcast_pkts_cnt (uint64)
YANG Description: Tx drop counter | f336362: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/gos_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 | f336362: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/gos_stats/rx_crc_error_cnt (uint64)
YANG Description: Rx crc error counter | f336362: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/gos_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 | f336362: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/gos_stats/rx_fifo_error_cnt (uint64)
YANG Description: Rx fifo error counter | f336362: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/gos_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 | f336362: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/gos_stats/rx_missed_errors_cnt (uint64)
YANG Description: Rx missed errors counter | f336362: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/gos_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 | f336362: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/gos_stats/rx_no_dma_resource_cnt (uint64)
YANG Description: Rx no dma resource | f336362: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/gos_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 | f336362: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/gos_stats/rx_flow_control_xon_cnt (uint64)
YANG Description: Rx flow control xon counter | f336362: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/gos_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 | f336362: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/gos_stats/rx_flow_control_xoff_cnt (uint64)
YANG Description: Rx flow control xoff counter | f336362: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/gos_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 | f336362: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/gos_stats/rx_pkts_64bytes_cnt (uint64)
YANG Description: Rx packets 64 bytes counter | f336362: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/gos_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 | f336362: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/gos_stats/rx_pkts_64_127bytes_cnt (uint64)
YANG Description: Rx packets 64 to 127 bytes counter | f336362: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/gos_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 | f336362: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/gos_stats/rx_pkts_128_255bytes_cnt (uint64)
YANG Description: Rx packets 128 to 255 bytes counter | f336362: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/gos_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 | f336362: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/gos_stats/rx_pkts_256_511bytes_cnt (uint64)
YANG Description: Rx packets 256 to 511 bytes counter | f336362: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/gos_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 | f336362: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/gos_stats/rx_pkts_512_1023bytes_cnt (uint64)
YANG Description: Rx packets 512 to 1023 bytes counter | f336362: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/gos_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 | f336362: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/gos_stats/rx_pkts_1024bytes_max_cnt (uint64)
YANG Description: Rx packets 1024 to Max bytes counter | f336362: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/gos_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 | f336362: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/gos_stats/rx_good_pkts_cnt (uint64)
YANG Description: Rx good pkts counter | f336362: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/gos_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 | f336362: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/gos_stats/rx_bcast_pkts_cnt (uint64)
YANG Description: Rx broadcast pkts counter | f336362: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/gos_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 | f336362: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/gos_stats/rx_mcast_pkts_cnt (uint64)
YANG Description: Rx multicast counter | f336362: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/gos_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 | f336362:c0:m124 |
def _get_ifname(self): | return self.__ifname<EOL> | Getter method for ifname, mapped from YANG variable /cpu_interface_state/ifname (string)
YANG Description: Interface name | f336363:c0:m3 |
def _set_ifname(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.__ifname = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ifname, mapped from YANG variable /cpu_interface_state/ifname (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_ifname is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ifname() directly.
YANG Description: Interface name | f336363:c0:m4 |
def _get_gos_stats(self): | return self.__gos_stats<EOL> | Getter method for gos_stats, mapped from YANG variable /cpu_interface_state/gos_stats (container) | f336363:c0:m6 |
def _set_gos_stats(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=gos_stats.gos_stats, is_container='<STR_LIT>', presence=False, 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>', 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.__gos_stats = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for gos_stats, mapped from YANG variable /cpu_interface_state/gos_stats (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_gos_stats is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_gos_stats() directly. | f336363:c0:m7 |
def _get_host_stats(self): | return self.__host_stats<EOL> | Getter method for host_stats, mapped from YANG variable /cpu_interface_state/host_stats (container) | f336363:c0:m9 |
def _set_host_stats(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=host_stats.host_stats, is_container='<STR_LIT>', presence=False, 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>', 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.__host_stats = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for host_stats, mapped from YANG variable /cpu_interface_state/host_stats (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_host_stats is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_host_stats() directly. | f336363:c0:m10 |
def _get_link_status(self): | return self.__link_status<EOL> | Getter method for link_status, mapped from YANG variable /cpu_interface_state/host_stats/link_status (string)
YANG Description: Link status | f336364:c0:m3 |
def _set_link_status(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.__link_status = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for link_status, mapped from YANG variable /cpu_interface_state/host_stats/link_status (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_link_status is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_link_status() directly.
YANG Description: Link status | f336364:c0:m4 |
def _get_tx_pkts_cnt(self): | return self.__tx_pkts_cnt<EOL> | Getter method for tx_pkts_cnt, mapped from YANG variable /cpu_interface_state/host_stats/tx_pkts_cnt (uint64)
YANG Description: Tx packets counter | f336364:c0:m6 |
def _set_tx_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_pkts_cnt = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for tx_pkts_cnt, mapped from YANG variable /cpu_interface_state/host_stats/tx_pkts_cnt (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_tx_pkts_cnt is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tx_pkts_cnt() directly.
YANG Description: Tx packets counter | f336364:c0:m7 |
def _get_tx_bytes_cnt(self): | return self.__tx_bytes_cnt<EOL> | Getter method for tx_bytes_cnt, mapped from YANG variable /cpu_interface_state/host_stats/tx_bytes_cnt (uint64)
YANG Description: Tx bytes counter | f336364:c0:m9 |
def _set_tx_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.__tx_bytes_cnt = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for tx_bytes_cnt, mapped from YANG variable /cpu_interface_state/host_stats/tx_bytes_cnt (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_tx_bytes_cnt is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tx_bytes_cnt() directly.
YANG Description: Tx bytes counter | f336364:c0:m10 |
def _get_tx_errors_cnt(self): | return self.__tx_errors_cnt<EOL> | Getter method for tx_errors_cnt, mapped from YANG variable /cpu_interface_state/host_stats/tx_errors_cnt (uint64)
YANG Description: Tx error counter | f336364:c0:m12 |
def _set_tx_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.__tx_errors_cnt = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for tx_errors_cnt, mapped from YANG variable /cpu_interface_state/host_stats/tx_errors_cnt (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_tx_errors_cnt is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tx_errors_cnt() directly.
YANG Description: Tx error counter | f336364:c0:m13 |
def _get_tx_drop_cnt(self): | return self.__tx_drop_cnt<EOL> | Getter method for tx_drop_cnt, mapped from YANG variable /cpu_interface_state/host_stats/tx_drop_cnt (uint64)
YANG Description: Tx drop counter | f336364:c0:m15 |
def _set_tx_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.__tx_drop_cnt = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for tx_drop_cnt, mapped from YANG variable /cpu_interface_state/host_stats/tx_drop_cnt (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_tx_drop_cnt is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tx_drop_cnt() directly.
YANG Description: Tx drop counter | f336364:c0:m16 |
def _get_tx_overrun_error_cnt(self): | return self.__tx_overrun_error_cnt<EOL> | Getter method for tx_overrun_error_cnt, mapped from YANG variable /cpu_interface_state/host_stats/tx_overrun_error_cnt (uint64)
YANG Description: Tx overrun error counter | f336364:c0:m18 |
def _set_tx_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.__tx_overrun_error_cnt = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for tx_overrun_error_cnt, mapped from YANG variable /cpu_interface_state/host_stats/tx_overrun_error_cnt (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_tx_overrun_error_cnt is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tx_overrun_error_cnt() directly.
YANG Description: Tx overrun error counter | f336364:c0:m19 |
def _get_tx_carrier_error_cnt(self): | return self.__tx_carrier_error_cnt<EOL> | Getter method for tx_carrier_error_cnt, mapped from YANG variable /cpu_interface_state/host_stats/tx_carrier_error_cnt (uint64)
YANG Description: Tx carrier error counter | f336364:c0:m21 |
def _set_tx_carrier_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_carrier_error_cnt = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for tx_carrier_error_cnt, mapped from YANG variable /cpu_interface_state/host_stats/tx_carrier_error_cnt (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_tx_carrier_error_cnt is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tx_carrier_error_cnt() directly.
YANG Description: Tx carrier error counter | f336364:c0:m22 |
def _get_rx_pkts_cnt(self): | return self.__rx_pkts_cnt<EOL> | Getter method for rx_pkts_cnt, mapped from YANG variable /cpu_interface_state/host_stats/rx_pkts_cnt (uint64)
YANG Description: Rx packets counter | f336364:c0:m24 |
def _set_rx_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_pkts_cnt = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rx_pkts_cnt, mapped from YANG variable /cpu_interface_state/host_stats/rx_pkts_cnt (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_rx_pkts_cnt is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rx_pkts_cnt() directly.
YANG Description: Rx packets counter | f336364:c0:m25 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.