signature
stringlengths 8
3.44k
| body
stringlengths 0
1.41M
| docstring
stringlengths 1
122k
| id
stringlengths 5
17
|
|---|---|---|---|
def _get_fwd_term(self): | return self.__fwd_term<EOL> | Getter method for fwd_term, mapped from YANG variable /lag/hash/hdr_start/fwd_term (enumeration) | f337157:c0:m3 |
def _set_fwd_term(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}},), 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, u'<STR_LIT>': None}}, 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.__fwd_term = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for fwd_term, mapped from YANG variable /lag/hash/hdr_start/fwd_term (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_fwd_term is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_fwd_term() directly. | f337157:c0:m4 |
def _get_enable_eth_ip(self): | return self.__enable_eth_ip<EOL> | Getter method for enable_eth_ip, mapped from YANG variable /lag/hash/speculate_mpls/enable_eth_ip (enumeration) | f337158:c0:m3 |
def _set_enable_eth_ip(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:5>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:6>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:4>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:3>}},), 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, u'<STR_LIT>': None}}, 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.__enable_eth_ip = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for enable_eth_ip, mapped from YANG variable /lag/hash/speculate_mpls/enable_eth_ip (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_enable_eth_ip is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_enable_eth_ip() directly. | f337158:c0:m4 |
def _get_hdr_start(self): | return self.__hdr_start<EOL> | Getter method for hdr_start, mapped from YANG variable /lag/hash/hdr_start (container) | f337159:c0:m3 |
def _set_hdr_start(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=hdr_start.hdr_start, 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:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None}}, 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.__hdr_start = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for hdr_start, mapped from YANG variable /lag/hash/hdr_start (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_hdr_start is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_hdr_start() directly. | f337159:c0:m4 |
def _get_bos(self): | return self.__bos<EOL> | Getter method for bos, mapped from YANG variable /lag/hash/bos (container) | f337159:c0:m6 |
def _set_bos(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=bos.bos, 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:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None}}, 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.__bos = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for bos, mapped from YANG variable /lag/hash/bos (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_bos is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_bos() directly. | f337159:c0:m7 |
def _get_hdr_count(self): | return self.__hdr_count<EOL> | Getter method for hdr_count, mapped from YANG variable /lag/hash/hdr_count (uint32) | f337159:c0:m9 |
def _set_hdr_count(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=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:info>': u'<STR_LIT>', u'<STR_LIT>': None}}, 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.__hdr_count = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for hdr_count, mapped from YANG variable /lag/hash/hdr_count (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_hdr_count is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_hdr_count() directly. | f337159:c0:m10 |
def _get_rotate(self): | return self.__rotate<EOL> | Getter method for rotate, mapped from YANG variable /lag/hash/rotate (uint32) | f337159:c0:m12 |
def _set_rotate(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=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:info>': u'<STR_LIT>', u'<STR_LIT>': None}}, 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.__rotate = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rotate, mapped from YANG variable /lag/hash/rotate (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_rotate is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rotate() directly. | f337159:c0:m13 |
def _get_normalize(self): | return self.__normalize<EOL> | Getter method for normalize, mapped from YANG variable /lag/hash/normalize (empty) | f337159:c0:m15 |
def _set_normalize(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}}, 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.__normalize = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for normalize, mapped from YANG variable /lag/hash/normalize (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_normalize is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_normalize() directly. | f337159:c0:m16 |
def _get_srcport(self): | return self.__srcport<EOL> | Getter method for srcport, mapped from YANG variable /lag/hash/srcport (empty) | f337159:c0:m18 |
def _set_srcport(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}}, 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.__srcport = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for srcport, mapped from YANG variable /lag/hash/srcport (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_srcport is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_srcport() directly. | f337159:c0:m19 |
def _get_pwctrlword(self): | return self.__pwctrlword<EOL> | Getter method for pwctrlword, mapped from YANG variable /lag/hash/pwctrlword (empty) | f337159:c0:m21 |
def _set_pwctrlword(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}}, 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.__pwctrlword = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for pwctrlword, mapped from YANG variable /lag/hash/pwctrlword (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_pwctrlword is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_pwctrlword() directly. | f337159:c0:m22 |
def _get_speculate_mpls(self): | return self.__speculate_mpls<EOL> | Getter method for speculate_mpls, mapped from YANG variable /lag/hash/speculate_mpls (container) | f337159:c0:m24 |
def _set_speculate_mpls(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=speculate_mpls.speculate_mpls, 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:info>': 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.__speculate_mpls = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for speculate_mpls, mapped from YANG variable /lag/hash/speculate_mpls (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_speculate_mpls is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_speculate_mpls() directly. | f337159:c0:m25 |
def _get_start_skip(self): | return self.__start_skip<EOL> | Getter method for start_skip, mapped from YANG variable /lag/hash/bos/start_skip (enumeration) | f337160:c0:m3 |
def _set_start_skip(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT:start>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}},), 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, u'<STR_LIT>': None}}, 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.__start_skip = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for start_skip, mapped from YANG variable /lag/hash/bos/start_skip (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_start_skip is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_start_skip() directly. | f337160:c0:m4 |
def _get_hash(self): | return self.__hash<EOL> | Getter method for hash, mapped from YANG variable /lag/hash (container) | f337161:c0:m3 |
def _set_hash(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=hash.hash, 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:info>': 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.__hash = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for hash, mapped from YANG variable /lag/hash (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_hash is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_hash() directly. | f337161:c0:m4 |
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. | f337162: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. | f337162: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) | f337162: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. | f337162: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 | f337163: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 | f337163: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. | f337163: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. | f337163:c0:m7 |
def _get_activate(self): | return self.__activate<EOL> | Getter method for activate, mapped from YANG variable /port_channel_redundancy_group/activate (empty) | f337163: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. | f337163: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) | f337164: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. | f337164: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) | f337164: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. | f337164:c0:m7 |
def _get_rspan(self): | return self.__rspan<EOL> | Getter method for rspan, mapped from YANG variable /capabilities/l2/rspan (boolean) | f337164: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. | f337164: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) | f337164: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. | f337164: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) | f337164: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. | f337164: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) | f337164: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. | f337164: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) | f337164: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. | f337164: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) | f337164: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. | f337164:c0:m25 |
def _get_lif_untagged_vlan_id(self): | return self.__lif_untagged_vlan_id<EOL> | Getter method for lif_untagged_vlan_id, mapped from YANG variable /capabilities/l2/lif_untagged_vlan_id (boolean) | f337164:c0:m27 |
def _set_lif_untagged_vlan_id(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.__lif_untagged_vlan_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for lif_untagged_vlan_id, mapped from YANG variable /capabilities/l2/lif_untagged_vlan_id (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_lif_untagged_vlan_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lif_untagged_vlan_id() directly. | f337164:c0:m28 |
def _get_lif_egress(self): | return self.__lif_egress<EOL> | Getter method for lif_egress, mapped from YANG variable /capabilities/l2/lif_egress (boolean) | f337164:c0:m30 |
def _set_lif_egress(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.__lif_egress = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for lif_egress, mapped from YANG variable /capabilities/l2/lif_egress (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_lif_egress is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lif_egress() directly. | f337164:c0:m31 |
def _get_lif_inner_vlan(self): | return self.__lif_inner_vlan<EOL> | Getter method for lif_inner_vlan, mapped from YANG variable /capabilities/l2/lif_inner_vlan (boolean) | f337164:c0:m33 |
def _set_lif_inner_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.__lif_inner_vlan = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for lif_inner_vlan, mapped from YANG variable /capabilities/l2/lif_inner_vlan (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_lif_inner_vlan is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lif_inner_vlan() directly. | f337164:c0:m34 |
def _get_bridgedomain_local_switching(self): | return self.__bridgedomain_local_switching<EOL> | Getter method for bridgedomain_local_switching, mapped from YANG variable /capabilities/l2/bridgedomain_local_switching (boolean) | f337164:c0:m36 |
def _set_bridgedomain_local_switching(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.__bridgedomain_local_switching = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for bridgedomain_local_switching, mapped from YANG variable /capabilities/l2/bridgedomain_local_switching (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_bridgedomain_local_switching is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_bridgedomain_local_switching() directly. | f337164:c0:m37 |
def _get_bridgedomain_transparent(self): | return self.__bridgedomain_transparent<EOL> | Getter method for bridgedomain_transparent, mapped from YANG variable /capabilities/l2/bridgedomain_transparent (boolean) | f337164:c0:m39 |
def _set_bridgedomain_transparent(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.__bridgedomain_transparent = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for bridgedomain_transparent, mapped from YANG variable /capabilities/l2/bridgedomain_transparent (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_bridgedomain_transparent is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_bridgedomain_transparent() directly. | f337164:c0:m40 |
def _get_dot1x(self): | return self.__dot1x<EOL> | Getter method for dot1x, mapped from YANG variable /capabilities/l2/dot1x (boolean) | f337164:c0:m42 |
def _set_dot1x(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.__dot1x = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for dot1x, mapped from YANG variable /capabilities/l2/dot1x (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_dot1x is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_dot1x() directly. | f337164:c0:m43 |
def _get_ip_mtu(self): | return self.__ip_mtu<EOL> | Getter method for ip_mtu, mapped from YANG variable /capabilities/l3/ip_mtu (boolean) | f337165:c0:m3 |
def _set_ip_mtu(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.__ip_mtu = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ip_mtu, mapped from YANG variable /capabilities/l3/ip_mtu (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_ip_mtu is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ip_mtu() directly. | f337165:c0:m4 |
def _get_vrrp_extended_group_phy(self): | return self.__vrrp_extended_group_phy<EOL> | Getter method for vrrp_extended_group_phy, mapped from YANG variable /capabilities/l3/vrrp_extended_group_phy (boolean) | f337165:c0:m6 |
def _set_vrrp_extended_group_phy(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.__vrrp_extended_group_phy = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vrrp_extended_group_phy, mapped from YANG variable /capabilities/l3/vrrp_extended_group_phy (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_vrrp_extended_group_phy is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vrrp_extended_group_phy() directly. | f337165:c0:m7 |
def _get_igmp_snooping_version(self): | return self.__igmp_snooping_version<EOL> | Getter method for igmp_snooping_version, mapped from YANG variable /capabilities/ip/igmp_snooping/igmp_snooping_version (boolean) | f337166:c0:m3 |
def _set_igmp_snooping_version(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.__igmp_snooping_version = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for igmp_snooping_version, mapped from YANG variable /capabilities/ip/igmp_snooping/igmp_snooping_version (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_igmp_snooping_version is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_igmp_snooping_version() directly. | f337166:c0:m4 |
def _get_igmp(self): | return self.__igmp<EOL> | Getter method for igmp, mapped from YANG variable /capabilities/ip/igmp (boolean) | f337167:c0:m3 |
def _set_igmp(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.__igmp = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for igmp, mapped from YANG variable /capabilities/ip/igmp (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_igmp is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_igmp() directly. | f337167:c0:m4 |
def _get_igmp_snooping(self): | return self.__igmp_snooping<EOL> | Getter method for igmp_snooping, mapped from YANG variable /capabilities/ip/igmp_snooping (container) | f337167:c0:m6 |
def _set_igmp_snooping(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=igmp_snooping.igmp_snooping, 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.__igmp_snooping = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for igmp_snooping, mapped from YANG variable /capabilities/ip/igmp_snooping (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_igmp_snooping is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_igmp_snooping() directly. | f337167:c0:m7 |
def _get_qos_mpls(self): | return self.__qos_mpls<EOL> | Getter method for qos_mpls, mapped from YANG variable /capabilities/maps/qos_mpls (boolean) | f337168:c0:m3 |
def _set_qos_mpls(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.__qos_mpls = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for qos_mpls, mapped from YANG variable /capabilities/maps/qos_mpls (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_qos_mpls is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_qos_mpls() directly. | f337168:c0:m4 |
def _get_nas(self): | return self.__nas<EOL> | Getter method for nas, mapped from YANG variable /capabilities/qos/cee/nas (boolean) | f337169:c0:m3 |
def _set_nas(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.__nas = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for nas, mapped from YANG variable /capabilities/qos/cee/nas (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_nas is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_nas() directly. | f337169:c0:m4 |
def _get_system_rx_queue_limit(self): | return self.__system_rx_queue_limit<EOL> | Getter method for system_rx_queue_limit, mapped from YANG variable /capabilities/qos/system_rx_queue_limit (boolean) | f337170:c0:m3 |
def _set_system_rx_queue_limit(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.__system_rx_queue_limit = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for system_rx_queue_limit, mapped from YANG variable /capabilities/qos/system_rx_queue_limit (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_system_rx_queue_limit is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_system_rx_queue_limit() directly. | f337170:c0:m4 |
def _get_system_tx_queue_limit(self): | return self.__system_tx_queue_limit<EOL> | Getter method for system_tx_queue_limit, mapped from YANG variable /capabilities/qos/system_tx_queue_limit (boolean) | f337170:c0:m6 |
def _set_system_tx_queue_limit(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.__system_tx_queue_limit = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for system_tx_queue_limit, mapped from YANG variable /capabilities/qos/system_tx_queue_limit (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_system_tx_queue_limit is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_system_tx_queue_limit() directly. | f337170:c0:m7 |
def _get_show_rx_queue_interface(self): | return self.__show_rx_queue_interface<EOL> | Getter method for show_rx_queue_interface, mapped from YANG variable /capabilities/qos/show_rx_queue_interface (boolean) | f337170:c0:m9 |
def _set_show_rx_queue_interface(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.__show_rx_queue_interface = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for show_rx_queue_interface, mapped from YANG variable /capabilities/qos/show_rx_queue_interface (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_show_rx_queue_interface is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_show_rx_queue_interface() directly. | f337170:c0:m10 |
def _get_conf_rx_queue_interface(self): | return self.__conf_rx_queue_interface<EOL> | Getter method for conf_rx_queue_interface, mapped from YANG variable /capabilities/qos/conf_rx_queue_interface (boolean) | f337170:c0:m12 |
def _set_conf_rx_queue_interface(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.__conf_rx_queue_interface = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for conf_rx_queue_interface, mapped from YANG variable /capabilities/qos/conf_rx_queue_interface (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_conf_rx_queue_interface is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_conf_rx_queue_interface() directly. | f337170:c0:m13 |
def _get_cee(self): | return self.__cee<EOL> | Getter method for cee, mapped from YANG variable /capabilities/qos/cee (container) | f337170:c0:m15 |
def _set_cee(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=cee.cee, 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.__cee = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for cee, mapped from YANG variable /capabilities/qos/cee (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_cee is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_cee() directly. | f337170:c0:m16 |
def _get_cpu(self): | return self.__cpu<EOL> | Getter method for cpu, mapped from YANG variable /capabilities/qos/cpu (container) | f337170:c0:m18 |
def _set_cpu(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=cpu.cpu, 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.__cpu = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for cpu, mapped from YANG variable /capabilities/qos/cpu (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_cpu is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_cpu() directly. | f337170:c0:m19 |
def _get_slot(self): | return self.__slot<EOL> | Getter method for slot, mapped from YANG variable /capabilities/qos/cpu/slot (boolean) | f337171:c0:m3 |
def _set_slot(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 = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for slot, mapped from YANG variable /capabilities/qos/cpu/slot (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_slot is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_slot() directly. | f337171:c0:m4 |
def _get_queue(self): | return self.__queue<EOL> | Getter method for queue, mapped from YANG variable /capabilities/qos/cpu/queue (boolean) | f337171:c0:m6 |
def _set_queue(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.__queue = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for queue, mapped from YANG variable /capabilities/qos/cpu/queue (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_queue is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_queue() directly. | f337171:c0:m7 |
def _get_mac_learn_protocol_bgp(self): | return self.__mac_learn_protocol_bgp<EOL> | Getter method for mac_learn_protocol_bgp, mapped from YANG variable /capabilities/overlay/vxlan/mac_learn_protocol_bgp (boolean) | f337172:c0:m3 |
def _set_mac_learn_protocol_bgp(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_learn_protocol_bgp = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mac_learn_protocol_bgp, mapped from YANG variable /capabilities/overlay/vxlan/mac_learn_protocol_bgp (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_mac_learn_protocol_bgp is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mac_learn_protocol_bgp() directly. | f337172:c0:m4 |
def _get_gre(self): | return self.__gre<EOL> | Getter method for gre, mapped from YANG variable /capabilities/overlay/gre (boolean) | f337173:c0:m3 |
def _set_gre(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.__gre = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for gre, mapped from YANG variable /capabilities/overlay/gre (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_gre is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_gre() directly. | f337173:c0:m4 |
def _get_vxlan(self): | return self.__vxlan<EOL> | Getter method for vxlan, mapped from YANG variable /capabilities/overlay/vxlan (container) | f337173:c0:m6 |
def _set_vxlan(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=vxlan.vxlan, 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.__vxlan = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vxlan, mapped from YANG variable /capabilities/overlay/vxlan (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_vxlan is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vxlan() directly. | f337173:c0:m7 |
def _get_hardware_vtep(self): | return self.__hardware_vtep<EOL> | Getter method for hardware_vtep, mapped from YANG variable /capabilities/overlay/hardware_vtep (boolean)
YANG Description: Indicates whether hardware_vtep gateway is
supported. This type of gateway requires NSX or
similar VTEP controller integration. | f337173:c0:m9 |
def _set_hardware_vtep(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.__hardware_vtep = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for hardware_vtep, mapped from YANG variable /capabilities/overlay/hardware_vtep (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_hardware_vtep is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_hardware_vtep() directly.
YANG Description: Indicates whether hardware_vtep gateway is
supported. This type of gateway requires NSX or
similar VTEP controller integration. | f337173:c0:m10 |