signature stringlengths 8 3.44k | body stringlengths 0 1.41M | docstring stringlengths 1 122k | id stringlengths 5 17 |
|---|---|---|---|
def _get_in_broadcast_pkts(self): | return self.__in_broadcast_pkts<EOL> | Getter method for in_broadcast_pkts, mapped from YANG variable /interface_statistics_state/interface_counters/in_broadcast_pkts (uint64)
YANG Description: Total number of broadcast packets received | f335733:c0:m15 |
def _set_in_broadcast_pkts(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.__in_broadcast_pkts = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for in_broadcast_pkts, mapped from YANG variable /interface_statistics_state/interface_counters/in_broadcast_pkts (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_in_broadcast_pkts is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_in_broadcast_pkts() directly.
YANG Description: Total number of broadcast packets received | f335733:c0:m16 |
def _get_in_multicast_pkts(self): | return self.__in_multicast_pkts<EOL> | Getter method for in_multicast_pkts, mapped from YANG variable /interface_statistics_state/interface_counters/in_multicast_pkts (uint64)
YANG Description: Total number of multicast packets received | f335733:c0:m18 |
def _set_in_multicast_pkts(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.__in_multicast_pkts = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for in_multicast_pkts, mapped from YANG variable /interface_statistics_state/interface_counters/in_multicast_pkts (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_in_multicast_pkts is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_in_multicast_pkts() directly.
YANG Description: Total number of multicast packets received | f335733:c0:m19 |
def _get_in_pkts_per_second(self): | return self.__in_pkts_per_second<EOL> | Getter method for in_pkts_per_second, mapped from YANG variable /interface_statistics_state/interface_counters/in_pkts_per_second (uint64)
YANG Description: Total number of packets received per second | f335733:c0:m21 |
def _set_in_pkts_per_second(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.__in_pkts_per_second = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for in_pkts_per_second, mapped from YANG variable /interface_statistics_state/interface_counters/in_pkts_per_second (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_in_pkts_per_second is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_in_pkts_per_second() directly.
YANG Description: Total number of packets received per second | f335733:c0:m22 |
def _get_in_bandwidth(self): | return self.__in_bandwidth<EOL> | Getter method for in_bandwidth, mapped from YANG variable /interface_statistics_state/interface_counters/in_bandwidth (uint64)
YANG Description: Bandwidth received | f335733:c0:m24 |
def _set_in_bandwidth(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.__in_bandwidth = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for in_bandwidth, mapped from YANG variable /interface_statistics_state/interface_counters/in_bandwidth (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_in_bandwidth is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_in_bandwidth() directly.
YANG Description: Bandwidth received | f335733:c0:m25 |
def _get_in_octets(self): | return self.__in_octets<EOL> | Getter method for in_octets, mapped from YANG variable /interface_statistics_state/interface_counters/in_octets (uint64)
YANG Description: Total number of bytes received | f335733:c0:m27 |
def _set_in_octets(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.__in_octets = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for in_octets, mapped from YANG variable /interface_statistics_state/interface_counters/in_octets (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_in_octets is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_in_octets() directly.
YANG Description: Total number of bytes received | f335733:c0:m28 |
def _get_in_errors(self): | return self.__in_errors<EOL> | Getter method for in_errors, mapped from YANG variable /interface_statistics_state/interface_counters/in_errors (uint64)
YANG Description: Number of errors | f335733:c0:m30 |
def _set_in_errors(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.__in_errors = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for in_errors, mapped from YANG variable /interface_statistics_state/interface_counters/in_errors (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_in_errors is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_in_errors() directly.
YANG Description: Number of errors | f335733:c0:m31 |
def _get_in_crc_errors(self): | return self.__in_crc_errors<EOL> | Getter method for in_crc_errors, mapped from YANG variable /interface_statistics_state/interface_counters/in_crc_errors (uint64)
YANG Description: Number of crc errors | f335733:c0:m33 |
def _set_in_crc_errors(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.__in_crc_errors = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for in_crc_errors, mapped from YANG variable /interface_statistics_state/interface_counters/in_crc_errors (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_in_crc_errors is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_in_crc_errors() directly.
YANG Description: Number of crc errors | f335733:c0:m34 |
def _get_in_discards(self): | return self.__in_discards<EOL> | Getter method for in_discards, mapped from YANG variable /interface_statistics_state/interface_counters/in_discards (uint64)
YANG Description: Number of packet drops in receiving | f335733:c0:m36 |
def _set_in_discards(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.__in_discards = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for in_discards, mapped from YANG variable /interface_statistics_state/interface_counters/in_discards (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_in_discards is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_in_discards() directly.
YANG Description: Number of packet drops in receiving | f335733:c0:m37 |
def _get_out_pkts(self): | return self.__out_pkts<EOL> | Getter method for out_pkts, mapped from YANG variable /interface_statistics_state/interface_counters/out_pkts (uint64)
YANG Description: Total number of packets transmitted | f335733:c0:m39 |
def _set_out_pkts(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.__out_pkts = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for out_pkts, mapped from YANG variable /interface_statistics_state/interface_counters/out_pkts (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_out_pkts is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_out_pkts() directly.
YANG Description: Total number of packets transmitted | f335733:c0:m40 |
def _get_out_unicast_pkts(self): | return self.__out_unicast_pkts<EOL> | Getter method for out_unicast_pkts, mapped from YANG variable /interface_statistics_state/interface_counters/out_unicast_pkts (uint64)
YANG Description: Total number of unicast packets transmitted | f335733:c0:m42 |
def _set_out_unicast_pkts(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.__out_unicast_pkts = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for out_unicast_pkts, mapped from YANG variable /interface_statistics_state/interface_counters/out_unicast_pkts (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_out_unicast_pkts is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_out_unicast_pkts() directly.
YANG Description: Total number of unicast packets transmitted | f335733:c0:m43 |
def _get_out_broadcast_pkts(self): | return self.__out_broadcast_pkts<EOL> | Getter method for out_broadcast_pkts, mapped from YANG variable /interface_statistics_state/interface_counters/out_broadcast_pkts (uint64)
YANG Description: Total number of broadcast packets transmitted | f335733:c0:m45 |
def _set_out_broadcast_pkts(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.__out_broadcast_pkts = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for out_broadcast_pkts, mapped from YANG variable /interface_statistics_state/interface_counters/out_broadcast_pkts (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_out_broadcast_pkts is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_out_broadcast_pkts() directly.
YANG Description: Total number of broadcast packets transmitted | f335733:c0:m46 |
def _get_out_multicast_pkts(self): | return self.__out_multicast_pkts<EOL> | Getter method for out_multicast_pkts, mapped from YANG variable /interface_statistics_state/interface_counters/out_multicast_pkts (uint64)
YANG Description: Total number of multicast packets transmitted | f335733:c0:m48 |
def _set_out_multicast_pkts(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.__out_multicast_pkts = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for out_multicast_pkts, mapped from YANG variable /interface_statistics_state/interface_counters/out_multicast_pkts (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_out_multicast_pkts is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_out_multicast_pkts() directly.
YANG Description: Total number of multicast packets transmitted | f335733:c0:m49 |
def _get_out_pkts_per_second(self): | return self.__out_pkts_per_second<EOL> | Getter method for out_pkts_per_second, mapped from YANG variable /interface_statistics_state/interface_counters/out_pkts_per_second (uint64)
YANG Description: Total number of packets transmitted per second | f335733:c0:m51 |
def _set_out_pkts_per_second(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.__out_pkts_per_second = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for out_pkts_per_second, mapped from YANG variable /interface_statistics_state/interface_counters/out_pkts_per_second (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_out_pkts_per_second is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_out_pkts_per_second() directly.
YANG Description: Total number of packets transmitted per second | f335733:c0:m52 |
def _get_out_bandwidth(self): | return self.__out_bandwidth<EOL> | Getter method for out_bandwidth, mapped from YANG variable /interface_statistics_state/interface_counters/out_bandwidth (uint64)
YANG Description: Bandwidth transmitted | f335733:c0:m54 |
def _set_out_bandwidth(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.__out_bandwidth = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for out_bandwidth, mapped from YANG variable /interface_statistics_state/interface_counters/out_bandwidth (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_out_bandwidth is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_out_bandwidth() directly.
YANG Description: Bandwidth transmitted | f335733:c0:m55 |
def _get_out_octets(self): | return self.__out_octets<EOL> | Getter method for out_octets, mapped from YANG variable /interface_statistics_state/interface_counters/out_octets (uint64)
YANG Description: Total number of bytes transmitted | f335733:c0:m57 |
def _set_out_octets(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.__out_octets = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for out_octets, mapped from YANG variable /interface_statistics_state/interface_counters/out_octets (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_out_octets is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_out_octets() directly.
YANG Description: Total number of bytes transmitted | f335733:c0:m58 |
def _get_out_errors(self): | return self.__out_errors<EOL> | Getter method for out_errors, mapped from YANG variable /interface_statistics_state/interface_counters/out_errors (uint64)
YANG Description: Number of errors in transmitting | f335733:c0:m60 |
def _set_out_errors(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.__out_errors = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for out_errors, mapped from YANG variable /interface_statistics_state/interface_counters/out_errors (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_out_errors is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_out_errors() directly.
YANG Description: Number of errors in transmitting | f335733:c0:m61 |
def _get_out_crc_errors(self): | return self.__out_crc_errors<EOL> | Getter method for out_crc_errors, mapped from YANG variable /interface_statistics_state/interface_counters/out_crc_errors (uint64)
YANG Description: Number of crc errors in transmitting | f335733:c0:m63 |
def _set_out_crc_errors(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.__out_crc_errors = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for out_crc_errors, mapped from YANG variable /interface_statistics_state/interface_counters/out_crc_errors (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_out_crc_errors is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_out_crc_errors() directly.
YANG Description: Number of crc errors in transmitting | f335733:c0:m64 |
def _get_out_discards(self): | return self.__out_discards<EOL> | Getter method for out_discards, mapped from YANG variable /interface_statistics_state/interface_counters/out_discards (uint64)
YANG Description: Number of packet drops in transmitting | f335733:c0:m66 |
def _set_out_discards(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.__out_discards = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for out_discards, mapped from YANG variable /interface_statistics_state/interface_counters/out_discards (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_out_discards is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_out_discards() directly.
YANG Description: Number of packet drops in transmitting | f335733:c0:m67 |
def _get_profile_name(self): | return self.__profile_name<EOL> | Getter method for profile_name, mapped from YANG variable /interface_statistics_state/profile_name (string)
YANG Description: Profile name | f335734:c0:m3 |
def _set_profile_name(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.__profile_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for profile_name, mapped from YANG variable /interface_statistics_state/profile_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_profile_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_profile_name() directly.
YANG Description: Profile name | f335734:c0:m4 |
def _get_interface_counters(self): | return self.__interface_counters<EOL> | Getter method for interface_counters, mapped from YANG variable /interface_statistics_state/interface_counters (container)
YANG Description: Interface counters | f335734:c0:m6 |
def _set_interface_counters(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=interface_counters.interface_counters, 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>', u'<STR_LIT>': None}}, 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.__interface_counters = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for interface_counters, mapped from YANG variable /interface_statistics_state/interface_counters (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_interface_counters is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_interface_counters() directly.
YANG Description: Interface counters | f335734:c0:m7 |
def _get_name(self): | return self.__name<EOL> | Getter method for name, mapped from YANG variable /port_channel_redundancy_group/port_channel/name (interface:portchannel-type)
YANG Description: The port-channel identifier. | f335735:c0:m3 |
def _set_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=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT:name>", rest_name="<STR_LIT:name>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None}}, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<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.__name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for name, mapped from YANG variable /port_channel_redundancy_group/port_channel/name (interface:portchannel-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_name() directly.
YANG Description: The port-channel identifier. | f335735:c0:m4 |
def _get_port_channel_active(self): | return self.__port_channel_active<EOL> | Getter method for port_channel_active, mapped from YANG variable /port_channel_redundancy_group/port_channel/port_channel_active (empty) | f335735:c0:m6 |
def _set_port_channel_active(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, is_leaf=True, 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>': None, u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<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.__port_channel_active = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for port_channel_active, mapped from YANG variable /port_channel_redundancy_group/port_channel/port_channel_active (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_port_channel_active is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_port_channel_active() directly. | f335735:c0:m7 |
def _get_group_id(self): | return self.__group_id<EOL> | Getter method for group_id, mapped from YANG variable /port_channel_redundancy_group/group_id (po-redundancy-group-type)
YANG Description: The port-channel-redundancy-group identifier | f335736:c0:m3 |
def _set_group_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=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), 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, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT>': None}}, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<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_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for group_id, mapped from YANG variable /port_channel_redundancy_group/group_id (po-redundancy-group-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_group_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_group_id() directly.
YANG Description: The port-channel-redundancy-group identifier | f335736:c0:m4 |
def _get_port_channel(self): | return self.__port_channel<EOL> | Getter method for port_channel, mapped from YANG variable /port_channel_redundancy_group/port_channel (list)
YANG Description: The list of port-channels in the managed device. Each
entry represents a port-channel. | f335736:c0:m6 |
def _set_port_channel(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:name>",port_channel.port_channel, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=True, path_helper=self._path_helper, yang_keys='<STR_LIT:name>', extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, 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:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=True)<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.__port_channel = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for port_channel, mapped from YANG variable /port_channel_redundancy_group/port_channel (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_port_channel is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_port_channel() directly.
YANG Description: The list of port-channels in the managed device. Each
entry represents a port-channel. | f335736:c0:m7 |
def _get_activate(self): | return self.__activate<EOL> | Getter method for activate, mapped from YANG variable /port_channel_redundancy_group/activate (empty) | f335736:c0:m9 |
def _set_activate(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, is_leaf=True, 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>': None, u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<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.__activate = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for activate, mapped from YANG variable /port_channel_redundancy_group/activate (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_activate is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_activate() directly. | f335736:c0:m10 |
def _get_port_profile(self): | return self.__port_profile<EOL> | Getter method for port_profile, mapped from YANG variable /capabilities/l2/port_profile (boolean) | f335737:c0:m3 |
def _set_port_profile(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, 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.__port_profile = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for port_profile, mapped from YANG variable /capabilities/l2/port_profile (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_port_profile is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_port_profile() directly. | f335737:c0:m4 |
def _get_overlap_vlan(self): | return self.__overlap_vlan<EOL> | Getter method for overlap_vlan, mapped from YANG variable /capabilities/l2/overlap_vlan (boolean) | f335737:c0:m6 |
def _set_overlap_vlan(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, 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.__overlap_vlan = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for overlap_vlan, mapped from YANG variable /capabilities/l2/overlap_vlan (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_overlap_vlan is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_overlap_vlan() directly. | f335737:c0:m7 |
def _get_rspan(self): | return self.__rspan<EOL> | Getter method for rspan, mapped from YANG variable /capabilities/l2/rspan (boolean) | f335737:c0:m9 |
def _set_rspan(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, 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.__rspan = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rspan, mapped from YANG variable /capabilities/l2/rspan (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_rspan is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rspan() directly. | f335737:c0:m10 |
def _get_mac_move(self): | return self.__mac_move<EOL> | Getter method for mac_move, mapped from YANG variable /capabilities/l2/mac_move (boolean) | f335737:c0:m12 |
def _set_mac_move(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, 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.__mac_move = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mac_move, mapped from YANG variable /capabilities/l2/mac_move (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_mac_move is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mac_move() directly. | f335737:c0:m13 |
def _get_consistency_check(self): | return self.__consistency_check<EOL> | Getter method for consistency_check, mapped from YANG variable /capabilities/l2/consistency_check (boolean) | f335737:c0:m15 |
def _set_consistency_check(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, 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.__consistency_check = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for consistency_check, mapped from YANG variable /capabilities/l2/consistency_check (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_consistency_check is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_consistency_check() directly. | f335737:c0:m16 |
def _get_learning_mode(self): | return self.__learning_mode<EOL> | Getter method for learning_mode, mapped from YANG variable /capabilities/l2/learning_mode (boolean) | f335737:c0:m18 |
def _set_learning_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=YANGBool, 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.__learning_mode = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for learning_mode, mapped from YANG variable /capabilities/l2/learning_mode (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_learning_mode is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_learning_mode() directly. | f335737:c0:m19 |
def _get_priority_tag(self): | return self.__priority_tag<EOL> | Getter method for priority_tag, mapped from YANG variable /capabilities/l2/priority_tag (boolean) | f335737:c0:m21 |
def _set_priority_tag(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, 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.__priority_tag = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for priority_tag, mapped from YANG variable /capabilities/l2/priority_tag (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_priority_tag is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_priority_tag() directly. | f335737:c0:m22 |
def _get_internal_nsm(self): | return self.__internal_nsm<EOL> | Getter method for internal_nsm, mapped from YANG variable /capabilities/l2/internal_nsm (boolean) | f335737:c0:m24 |
def _set_internal_nsm(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, 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.__internal_nsm = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for internal_nsm, mapped from YANG variable /capabilities/l2/internal_nsm (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_internal_nsm is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_internal_nsm() directly. | f335737:c0:m25 |
def _get_aclTrafficType(self): | return self.__aclTrafficType<EOL> | Getter method for aclTrafficType, mapped from YANG variable /capabilities/ssm/aclTrafficType (boolean) | f335738:c0:m3 |
def _set_aclTrafficType(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, 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.__aclTrafficType = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for aclTrafficType, mapped from YANG variable /capabilities/ssm/aclTrafficType (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_aclTrafficType is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_aclTrafficType() directly. | f335738:c0:m4 |
def _get_lc_sfm(self): | return self.__lc_sfm<EOL> | Getter method for lc_sfm, mapped from YANG variable /capabilities/power/lc_sfm (boolean) | f335739:c0:m3 |
def _set_lc_sfm(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, 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.__lc_sfm = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for lc_sfm, mapped from YANG variable /capabilities/power/lc_sfm (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_lc_sfm is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lc_sfm() directly. | f335739:c0:m4 |
def _get_psu_on_off(self): | return self.__psu_on_off<EOL> | Getter method for psu_on_off, mapped from YANG variable /capabilities/power/psu_on_off (boolean) | f335739:c0:m6 |
def _set_psu_on_off(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, 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.__psu_on_off = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for psu_on_off, mapped from YANG variable /capabilities/power/psu_on_off (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_psu_on_off is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_psu_on_off() directly. | f335739:c0:m7 |
def _get_rpf(self): | return self.__rpf<EOL> | Getter method for rpf, mapped from YANG variable /capabilities/l3/rpf (boolean) | f335740:c0:m3 |
def _set_rpf(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, 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.__rpf = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rpf, mapped from YANG variable /capabilities/l3/rpf (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_rpf is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rpf() directly. | f335740:c0:m4 |
def _get_eula_display(self): | return self.__eula_display<EOL> | Getter method for eula_display, mapped from YANG variable /capabilities/license/eula_display (boolean) | f335741:c0:m3 |
def _set_eula_display(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, 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.__eula_display = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for eula_display, mapped from YANG variable /capabilities/license/eula_display (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_eula_display is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_eula_display() directly. | f335741:c0:m4 |
def _get_dpod_display(self): | return self.__dpod_display<EOL> | Getter method for dpod_display, mapped from YANG variable /capabilities/license/dpod_display (boolean) | f335741:c0:m6 |
def _set_dpod_display(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, 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.__dpod_display = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for dpod_display, mapped from YANG variable /capabilities/license/dpod_display (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_dpod_display is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_dpod_display() directly. | f335741:c0:m7 |
def _get_slot_display(self): | return self.__slot_display<EOL> | Getter method for slot_display, mapped from YANG variable /capabilities/license/slot_display (boolean) | f335741:c0:m9 |
def _set_slot_display(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, 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.__slot_display = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for slot_display, mapped from YANG variable /capabilities/license/slot_display (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_slot_display is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_slot_display() directly. | f335741:c0:m10 |
def _get_span(self): | return self.__span<EOL> | Getter method for span, mapped from YANG variable /capabilities/qos/mqc/span (boolean) | f335742:c0:m3 |
def _set_span(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, 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.__span = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for span, mapped from YANG variable /capabilities/qos/mqc/span (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_span is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_span() directly. | f335742:c0:m4 |
def _get_vlan_based_actions(self): | return self.__vlan_based_actions<EOL> | Getter method for vlan_based_actions, mapped from YANG variable /capabilities/qos/mqc/vlan_based_actions (boolean) | f335742:c0:m6 |
def _set_vlan_based_actions(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, 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.__vlan_based_actions = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vlan_based_actions, mapped from YANG variable /capabilities/qos/mqc/vlan_based_actions (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_vlan_based_actions is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vlan_based_actions() directly. | f335742:c0:m7 |
def _get_bd_based_actions(self): | return self.__bd_based_actions<EOL> | Getter method for bd_based_actions, mapped from YANG variable /capabilities/qos/mqc/bd_based_actions (boolean) | f335742:c0:m9 |
def _set_bd_based_actions(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, 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.__bd_based_actions = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for bd_based_actions, mapped from YANG variable /capabilities/qos/mqc/bd_based_actions (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_bd_based_actions is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_bd_based_actions() directly. | f335742:c0:m10 |
def _get_mqc(self): | return self.__mqc<EOL> | Getter method for mqc, mapped from YANG variable /capabilities/qos/mqc (container) | f335743:c0:m3 |
def _set_mqc(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=mqc.mqc, 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=None, 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.__mqc = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mqc, mapped from YANG variable /capabilities/qos/mqc (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_mqc is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mqc() directly. | f335743:c0:m4 |
def _get_ipv6Raguard(self): | return self.__ipv6Raguard<EOL> | Getter method for ipv6Raguard, mapped from YANG variable /capabilities/ipv6/ipv6Raguard (boolean) | f335744:c0:m3 |
def _set_ipv6Raguard(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, 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.__ipv6Raguard = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ipv6Raguard, mapped from YANG variable /capabilities/ipv6/ipv6Raguard (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_ipv6Raguard is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ipv6Raguard() directly. | f335744:c0:m4 |
def _get_power(self): | return self.__power<EOL> | Getter method for power, mapped from YANG variable /capabilities/power (container) | f335745:c0:m3 |
def _set_power(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=power.power, 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=None, 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.__power = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for power, mapped from YANG variable /capabilities/power (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_power is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_power() directly. | f335745:c0:m4 |
def _get_temperature(self): | return self.__temperature<EOL> | Getter method for temperature, mapped from YANG variable /capabilities/temperature (container) | f335745:c0:m6 |
def _set_temperature(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=temperature.temperature, 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=None, 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.__temperature = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for temperature, mapped from YANG variable /capabilities/temperature (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_temperature is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_temperature() directly. | f335745:c0:m7 |
def _get_qos(self): | return self.__qos<EOL> | Getter method for qos, mapped from YANG variable /capabilities/qos (container) | f335745:c0:m9 |
def _set_qos(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=qos.qos, 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=None, 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.__qos = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for qos, mapped from YANG variable /capabilities/qos (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_qos is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_qos() directly. | f335745:c0:m10 |
def _get_l3(self): | return self.__l3<EOL> | Getter method for l3, mapped from YANG variable /capabilities/l3 (container) | f335745:c0:m12 |
def _set_l3(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=l3.l3, 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=None, 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.__l3 = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for l3, mapped from YANG variable /capabilities/l3 (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_l3 is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_l3() directly. | f335745:c0:m13 |
def _get_l2(self): | return self.__l2<EOL> | Getter method for l2, mapped from YANG variable /capabilities/l2 (container) | f335745:c0:m15 |
def _set_l2(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=l2.l2, 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=None, 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.__l2 = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for l2, mapped from YANG variable /capabilities/l2 (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_l2 is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_l2() directly. | f335745:c0:m16 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.