signature
stringlengths 8
3.44k
| body
stringlengths 0
1.41M
| docstring
stringlengths 1
122k
| id
stringlengths 5
17
|
|---|---|---|---|
def _get_cost(self):
|
return self.__cost<EOL>
|
Getter method for cost, mapped from YANG variable /interface/ethernet/spanning_tree/cost (uint32)
|
f336629:c0:m6
|
def _set_cost(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, 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.__cost = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for cost, mapped from YANG variable /interface/ethernet/spanning_tree/cost (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_cost is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_cost() directly.
|
f336629:c0:m7
|
def _get_portfast(self):
|
return self.__portfast<EOL>
|
Getter method for portfast, mapped from YANG variable /interface/ethernet/spanning_tree/portfast (container)
|
f336629:c0:m9
|
def _set_portfast(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=portfast.portfast, 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>': 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.__portfast = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for portfast, mapped from YANG variable /interface/ethernet/spanning_tree/portfast (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_portfast is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_portfast() directly.
|
f336629:c0:m10
|
def _get_edgeport(self):
|
return self.__edgeport<EOL>
|
Getter method for edgeport, mapped from YANG variable /interface/ethernet/spanning_tree/edgeport (container)
|
f336629:c0:m12
|
def _set_edgeport(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=edgeport.edgeport, 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>': 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.__edgeport = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for edgeport, mapped from YANG variable /interface/ethernet/spanning_tree/edgeport (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_edgeport is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_edgeport() directly.
|
f336629:c0:m13
|
def _get_guard(self):
|
return self.__guard<EOL>
|
Getter method for guard, mapped from YANG variable /interface/ethernet/spanning_tree/guard (container)
|
f336629:c0:m15
|
def _set_guard(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=guard.guard, 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>': 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.__guard = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for guard, mapped from YANG variable /interface/ethernet/spanning_tree/guard (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_guard is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_guard() directly.
|
f336629:c0:m16
|
def _get_bpdu_mac(self):
|
return self.__bpdu_mac<EOL>
|
Getter method for bpdu_mac, mapped from YANG variable /interface/ethernet/spanning_tree/bpdu_mac (enumeration)
|
f336629:c0:m18
|
def _set_bpdu_mac(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>}},), 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.__bpdu_mac = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for bpdu_mac, mapped from YANG variable /interface/ethernet/spanning_tree/bpdu_mac (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_bpdu_mac is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_bpdu_mac() directly.
|
f336629:c0:m19
|
def _get_link_type(self):
|
return self.__link_type<EOL>
|
Getter method for link_type, mapped from YANG variable /interface/ethernet/spanning_tree/link_type (enumeration)
|
f336629:c0:m21
|
def _set_link_type(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>': {}, 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, 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.__link_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for link_type, mapped from YANG variable /interface/ethernet/spanning_tree/link_type (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_link_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_link_type() directly.
|
f336629:c0:m22
|
def _get_priority(self):
|
return self.__priority<EOL>
|
Getter method for priority, mapped from YANG variable /interface/ethernet/spanning_tree/priority (uint32)
|
f336629:c0:m24
|
def _set_priority(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, 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.__priority = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for priority, mapped from YANG variable /interface/ethernet/spanning_tree/priority (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_priority is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_priority() directly.
|
f336629:c0:m25
|
def _get_restricted_role(self):
|
return self.__restricted_role<EOL>
|
Getter method for restricted_role, mapped from YANG variable /interface/ethernet/spanning_tree/restricted_role (empty)
|
f336629:c0:m27
|
def _set_restricted_role(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.__restricted_role = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for restricted_role, mapped from YANG variable /interface/ethernet/spanning_tree/restricted_role (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_restricted_role is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_restricted_role() directly.
|
f336629:c0:m28
|
def _get_restricted_tcn(self):
|
return self.__restricted_tcn<EOL>
|
Getter method for restricted_tcn, mapped from YANG variable /interface/ethernet/spanning_tree/restricted_tcn (empty)
|
f336629:c0:m30
|
def _set_restricted_tcn(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.__restricted_tcn = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for restricted_tcn, mapped from YANG variable /interface/ethernet/spanning_tree/restricted_tcn (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_restricted_tcn is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_restricted_tcn() directly.
|
f336629:c0:m31
|
def _get_shutdown(self):
|
return self.__shutdown<EOL>
|
Getter method for shutdown, mapped from YANG variable /interface/ethernet/spanning_tree/shutdown (empty)
|
f336629:c0:m33
|
def _set_shutdown(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>': 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.__shutdown = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for shutdown, mapped from YANG variable /interface/ethernet/spanning_tree/shutdown (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_shutdown is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_shutdown() directly.
|
f336629:c0:m34
|
def _get_vlan(self):
|
return self.__vlan<EOL>
|
Getter method for vlan, mapped from YANG variable /interface/ethernet/spanning_tree/vlan (list)
|
f336629:c0:m36
|
def _set_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=YANGListType("<STR_LIT:id>",vlan.vlan, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT:id>', 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>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>'}}), is_container='<STR_LIT:list>', yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>', 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.__vlan = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for vlan, mapped from YANG variable /interface/ethernet/spanning_tree/vlan (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_vlan is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vlan() directly.
|
f336629:c0:m37
|
def _get_instance(self):
|
return self.__instance<EOL>
|
Getter method for instance, mapped from YANG variable /interface/ethernet/spanning_tree/instance (list)
|
f336629:c0:m39
|
def _set_instance(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:id>",instance.instance, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT:id>', 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>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>'}}), is_container='<STR_LIT:list>', yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>', 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.__instance = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for instance, mapped from YANG variable /interface/ethernet/spanning_tree/instance (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_instance is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_instance() directly.
|
f336629:c0:m40
|
def _get_edgeportbasic(self):
|
return self.__edgeportbasic<EOL>
|
Getter method for edgeportbasic, mapped from YANG variable /interface/ethernet/spanning_tree/edgeport/edgeportbasic (empty)
|
f336630:c0:m3
|
def _set_edgeportbasic(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: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.__edgeportbasic = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for edgeportbasic, mapped from YANG variable /interface/ethernet/spanning_tree/edgeport/edgeportbasic (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_edgeportbasic is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_edgeportbasic() directly.
|
f336630:c0:m4
|
def _get_bpdu_guard(self):
|
return self.__bpdu_guard<EOL>
|
Getter method for bpdu_guard, mapped from YANG variable /interface/ethernet/spanning_tree/edgeport/bpdu_guard (empty)
|
f336630:c0:m6
|
def _set_bpdu_guard(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>'}}, 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.__bpdu_guard = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for bpdu_guard, mapped from YANG variable /interface/ethernet/spanning_tree/edgeport/bpdu_guard (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_bpdu_guard is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_bpdu_guard() directly.
|
f336630:c0:m7
|
def _get_portfastbasic(self):
|
return self.__portfastbasic<EOL>
|
Getter method for portfastbasic, mapped from YANG variable /interface/ethernet/spanning_tree/portfast/portfastbasic (empty)
|
f336631:c0:m3
|
def _set_portfastbasic(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: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.__portfastbasic = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for portfastbasic, mapped from YANG variable /interface/ethernet/spanning_tree/portfast/portfastbasic (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_portfastbasic is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_portfastbasic() directly.
|
f336631:c0:m4
|
def _get_bpdu_guard(self):
|
return self.__bpdu_guard<EOL>
|
Getter method for bpdu_guard, mapped from YANG variable /interface/ethernet/spanning_tree/portfast/bpdu_guard (empty)
|
f336631:c0:m6
|
def _set_bpdu_guard(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>'}}, 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.__bpdu_guard = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for bpdu_guard, mapped from YANG variable /interface/ethernet/spanning_tree/portfast/bpdu_guard (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_bpdu_guard is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_bpdu_guard() directly.
|
f336631:c0:m7
|
def _get_mode(self):
|
return self.__mode<EOL>
|
Getter method for mode, mapped from YANG variable /interface/ethernet/rpf_mode/mode (enumeration)
|
f336632:c0:m3
|
def _set_mode(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT:strict>': {'<STR_LIT:value>': <NUM_LIT:3>}, 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}}, 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.__mode = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for mode, mapped from YANG variable /interface/ethernet/rpf_mode/mode (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_mode is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mode() directly.
|
f336632:c0:m4
|
def _get_enable(self):
|
return self.__enable<EOL>
|
Getter method for enable, mapped from YANG variable /interface/ethernet/protocol/ptp/enable (empty)
YANG Description: When present indicates PTP protocol is enabled.
Disabling PTP protocol will not clear other related
configurations.
|
f336633:c0:m3
|
def _set_enable(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: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.__enable = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for enable, mapped from YANG variable /interface/ethernet/protocol/ptp/enable (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_enable is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_enable() directly.
YANG Description: When present indicates PTP protocol is enabled.
Disabling PTP protocol will not clear other related
configurations.
|
f336633:c0:m4
|
def _get_announce_interval(self):
|
return self.__announce_interval<EOL>
|
Getter method for announce_interval, mapped from YANG variable /interface/ethernet/protocol/ptp/announce_interval (uint32)
YANG Description: Interval between PTP announce messages.
|
f336633:c0:m6
|
def _set_announce_interval(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>']}), default=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>)(<NUM_LIT:0>), 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: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.__announce_interval = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for announce_interval, mapped from YANG variable /interface/ethernet/protocol/ptp/announce_interval (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_announce_interval is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_announce_interval() directly.
YANG Description: Interval between PTP announce messages.
|
f336633:c0:m7
|
def _get_announce_timeout(self):
|
return self.__announce_timeout<EOL>
|
Getter method for announce_timeout, mapped from YANG variable /interface/ethernet/protocol/ptp/announce_timeout (uint32)
YANG Description: Timeout between PTP announce messages.
|
f336633:c0:m9
|
def _set_announce_timeout(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>']}), default=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>)(<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: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.__announce_timeout = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for announce_timeout, mapped from YANG variable /interface/ethernet/protocol/ptp/announce_timeout (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_announce_timeout is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_announce_timeout() directly.
YANG Description: Timeout between PTP announce messages.
|
f336633:c0:m10
|
def _get_sync_interval(self):
|
return self.__sync_interval<EOL>
|
Getter method for sync_interval, mapped from YANG variable /interface/ethernet/protocol/ptp/sync_interval (int32)
YANG Description: Interval between PTP synchronization messages.
|
f336633:c0:m12
|
def _set_sync_interval(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>']}), default=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>)(-<NUM_LIT:1>), 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: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.__sync_interval = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for sync_interval, mapped from YANG variable /interface/ethernet/protocol/ptp/sync_interval (int32)
If this variable is read-only (config: false) in the
source YANG file, then _set_sync_interval is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_sync_interval() directly.
YANG Description: Interval between PTP synchronization messages.
|
f336633:c0:m13
|
def _get_delay_request_min_interval(self):
|
return self.__delay_request_min_interval<EOL>
|
Getter method for delay_request_min_interval, mapped from YANG variable /interface/ethernet/protocol/ptp/delay_request_min_interval (int32)
YANG Description: Minimal interval allowed between PTP Delay-Request messages.
|
f336633:c0:m15
|
def _set_delay_request_min_interval(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>']}), default=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>)(-<NUM_LIT:1>), 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: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.__delay_request_min_interval = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for delay_request_min_interval, mapped from YANG variable /interface/ethernet/protocol/ptp/delay_request_min_interval (int32)
If this variable is read-only (config: false) in the
source YANG file, then _set_delay_request_min_interval is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_delay_request_min_interval() directly.
YANG Description: Minimal interval allowed between PTP Delay-Request messages.
|
f336633:c0:m16
|
def _get_ptp_vlan(self):
|
return self.__ptp_vlan<EOL>
|
Getter method for ptp_vlan, mapped from YANG variable /interface/ethernet/protocol/ptp/ptp_vlan (intf:vlan-type)
YANG Description: Vlan interface number.
|
f336633:c0:m18
|
def _set_ptp_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=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: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.__ptp_vlan = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for ptp_vlan, mapped from YANG variable /interface/ethernet/protocol/ptp/ptp_vlan (intf:vlan-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_ptp_vlan is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ptp_vlan() directly.
YANG Description: Vlan interface number.
|
f336633:c0:m19
|
def _get_ptp(self):
|
return self.__ptp<EOL>
|
Getter method for ptp, mapped from YANG variable /interface/ethernet/protocol/ptp (container)
YANG Description: PTP configuration. PTP protocol is enabled when
'protocol/ptp/enable' is set.
|
f336634:c0:m3
|
def _set_ptp(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=ptp.ptp, is_container='<STR_LIT>', presence=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:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', 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>', 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.__ptp = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for ptp, mapped from YANG variable /interface/ethernet/protocol/ptp (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_ptp is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ptp() directly.
YANG Description: PTP configuration. PTP protocol is enabled when
'protocol/ptp/enable' is set.
|
f336634:c0:m4
|
def _get_ipv6_access_list(self):
|
return self.__ipv6_access_list<EOL>
|
Getter method for ipv6_access_list, mapped from YANG variable /interface/ethernet/ipv6/access_group/ipv6_access_list (ipv6-l3-acl-policy-name)
|
f336635:c0:m3
|
def _set_ipv6_access_list(self, v, load=False):
|
parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>', '<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:info>': u'<STR_LIT>', u'<STR_LIT>': None, 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.__ipv6_access_list = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for ipv6_access_list, mapped from YANG variable /interface/ethernet/ipv6/access_group/ipv6_access_list (ipv6-l3-acl-policy-name)
If this variable is read-only (config: false) in the
source YANG file, then _set_ipv6_access_list is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ipv6_access_list() directly.
|
f336635:c0:m4
|
def _get_ip_direction(self):
|
return self.__ip_direction<EOL>
|
Getter method for ip_direction, mapped from YANG variable /interface/ethernet/ipv6/access_group/ip_direction (enumeration)
|
f336635:c0:m6
|
def _set_ip_direction(self, v, load=False):
|
parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}},), 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}}, 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.__ip_direction = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for ip_direction, mapped from YANG variable /interface/ethernet/ipv6/access_group/ip_direction (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_ip_direction is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ip_direction() directly.
|
f336635:c0:m7
|
def _get_traffic_type(self):
|
return self.__traffic_type<EOL>
|
Getter method for traffic_type, mapped from YANG variable /interface/ethernet/ipv6/access_group/traffic_type (enumeration)
|
f336635:c0:m9
|
def _set_traffic_type(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:3>}, 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.__traffic_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for traffic_type, mapped from YANG variable /interface/ethernet/ipv6/access_group/traffic_type (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_traffic_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_traffic_type() directly.
|
f336635:c0:m10
|
def _get_int_ipv6_router_isis(self):
|
return self.__int_ipv6_router_isis<EOL>
|
Getter method for int_ipv6_router_isis, mapped from YANG variable /interface/ethernet/ipv6/intf_ipv6_router_isis/int_ipv6_router_isis (container)
|
f336636:c0:m3
|
def _set_int_ipv6_router_isis(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=int_ipv6_router_isis.int_ipv6_router_isis, 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>': 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=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.__int_ipv6_router_isis = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for int_ipv6_router_isis, mapped from YANG variable /interface/ethernet/ipv6/intf_ipv6_router_isis/int_ipv6_router_isis (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_int_ipv6_router_isis is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_int_ipv6_router_isis() directly.
|
f336636:c0:m4
|
def _get_vrrp_suppress_interface_ra(self):
|
return self.__vrrp_suppress_interface_ra<EOL>
|
Getter method for vrrp_suppress_interface_ra, mapped from YANG variable /interface/ethernet/ipv6/ipv6_nd_ra/ipv6_intf_cmds/vrrp_suppress_interface_ra (empty)
|
f336637:c0:m3
|
def _set_vrrp_suppress_interface_ra(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>'}}, 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.__vrrp_suppress_interface_ra = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for vrrp_suppress_interface_ra, mapped from YANG variable /interface/ethernet/ipv6/ipv6_nd_ra/ipv6_intf_cmds/vrrp_suppress_interface_ra (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_vrrp_suppress_interface_ra is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vrrp_suppress_interface_ra() directly.
|
f336637:c0:m4
|
def _get_nd(self):
|
return self.__nd<EOL>
|
Getter method for nd, mapped from YANG variable /interface/ethernet/ipv6/ipv6_nd_ra/ipv6_intf_cmds/nd (container)
|
f336637:c0:m6
|
def _set_nd(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=nd.nd, 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>': 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.__nd = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for nd, mapped from YANG variable /interface/ethernet/ipv6/ipv6_nd_ra/ipv6_intf_cmds/nd (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_nd is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_nd() directly.
|
f336637:c0:m7
|
def _get_neighbor(self):
|
return self.__neighbor<EOL>
|
Getter method for neighbor, mapped from YANG variable /interface/ethernet/ipv6/ipv6_nd_ra/ipv6_intf_cmds/neighbor (list)
|
f336637:c0:m9
|
def _set_neighbor(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>",neighbor.neighbor, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT>', extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None}}), is_container='<STR_LIT:list>', yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': 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: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.__neighbor = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for neighbor, mapped from YANG variable /interface/ethernet/ipv6/ipv6_nd_ra/ipv6_intf_cmds/neighbor (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_neighbor is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_neighbor() directly.
|
f336637:c0:m10
|
def _get_suppressing_address(self):
|
return self.__suppressing_address<EOL>
|
Getter method for suppressing_address, mapped from YANG variable /interface/ethernet/ipv6/ipv6_nd_ra/ipv6_intf_cmds/nd/address/suppressing_address (list)
|
f336638:c0:m3
|
def _set_suppressing_address(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>",suppressing_address.suppressing_address, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT>', extensions={u'<STR_LIT>': {u'<STR_LIT>': 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>': 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.__suppressing_address = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for suppressing_address, mapped from YANG variable /interface/ethernet/ipv6/ipv6_nd_ra/ipv6_intf_cmds/nd/address/suppressing_address (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_suppressing_address is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_suppressing_address() directly.
|
f336638:c0:m4
|
def _get_address_suppress_all(self):
|
return self.__address_suppress_all<EOL>
|
Getter method for address_suppress_all, mapped from YANG variable /interface/ethernet/ipv6/ipv6_nd_ra/ipv6_intf_cmds/nd/address/address_suppress_all (empty)
|
f336638:c0:m6
|
def _set_address_suppress_all(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:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': 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.__address_suppress_all = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for address_suppress_all, mapped from YANG variable /interface/ethernet/ipv6/ipv6_nd_ra/ipv6_intf_cmds/nd/address/address_suppress_all (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_address_suppress_all is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_address_suppress_all() directly.
|
f336638:c0:m7
|
def _get_suppress_ipv6_address(self):
|
return self.__suppress_ipv6_address<EOL>
|
Getter method for suppress_ipv6_address, mapped from YANG variable /interface/ethernet/ipv6/ipv6_nd_ra/ipv6_intf_cmds/nd/address/suppressing_address/suppress_ipv6_address (inet:ipv6-address)
|
f336639:c0:m3
|
def _set_suppress_ipv6_address(self, v, load=False):
|
parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>'}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, 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.__suppress_ipv6_address = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for suppress_ipv6_address, mapped from YANG variable /interface/ethernet/ipv6/ipv6_nd_ra/ipv6_intf_cmds/nd/address/suppressing_address/suppress_ipv6_address (inet:ipv6-address)
If this variable is read-only (config: false) in the
source YANG file, then _set_suppress_ipv6_address is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_suppress_ipv6_address() directly.
|
f336639:c0:m4
|
def _get_suppress_per_address(self):
|
return self.__suppress_per_address<EOL>
|
Getter method for suppress_per_address, mapped from YANG variable /interface/ethernet/ipv6/ipv6_nd_ra/ipv6_intf_cmds/nd/address/suppressing_address/suppress_per_address (empty)
|
f336639:c0:m6
|
def _set_suppress_per_address(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>', 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.__suppress_per_address = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for suppress_per_address, mapped from YANG variable /interface/ethernet/ipv6/ipv6_nd_ra/ipv6_intf_cmds/nd/address/suppressing_address/suppress_per_address (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_suppress_per_address is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_suppress_per_address() directly.
|
f336639:c0:m7
|
def _get_raguard(self):
|
return self.__raguard<EOL>
|
Getter method for raguard, mapped from YANG variable /interface/ethernet/ipv6/raguard (empty)
|
f336640:c0:m3
|
def _set_raguard(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.__raguard = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for raguard, mapped from YANG variable /interface/ethernet/ipv6/raguard (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_raguard is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_raguard() directly.
|
f336640:c0:m4
|
def _get_ipv6_config(self):
|
return self.__ipv6_config<EOL>
|
Getter method for ipv6_config, mapped from YANG variable /interface/ethernet/ipv6/ipv6_config (container)
|
f336640:c0:m6
|
def _set_ipv6_config(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=ipv6_config.ipv6_config, 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>': 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.__ipv6_config = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for ipv6_config, mapped from YANG variable /interface/ethernet/ipv6/ipv6_config (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_ipv6_config is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ipv6_config() directly.
|
f336640:c0:m7
|
def _get_interface_phy_dhcp_conf(self):
|
return self.__interface_phy_dhcp_conf<EOL>
|
Getter method for interface_phy_dhcp_conf, mapped from YANG variable /interface/ethernet/ipv6/interface_phy_dhcp_conf (container)
|
f336640:c0:m9
|
def _set_interface_phy_dhcp_conf(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_phy_dhcp_conf.interface_phy_dhcp_conf, 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>': 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.__interface_phy_dhcp_conf = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for interface_phy_dhcp_conf, mapped from YANG variable /interface/ethernet/ipv6/interface_phy_dhcp_conf (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_interface_phy_dhcp_conf is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_interface_phy_dhcp_conf() directly.
|
f336640:c0:m10
|
def _get_icmpv6(self):
|
return self.__icmpv6<EOL>
|
Getter method for icmpv6, mapped from YANG variable /interface/ethernet/ipv6/icmpv6 (container)
|
f336640:c0:m12
|
def _set_icmpv6(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=icmpv6.icmpv6, 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>': 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=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.__icmpv6 = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for icmpv6, mapped from YANG variable /interface/ethernet/ipv6/icmpv6 (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_icmpv6 is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_icmpv6() directly.
|
f336640:c0:m13
|
def _get_access_group(self):
|
return self.__access_group<EOL>
|
Getter method for access_group, mapped from YANG variable /interface/ethernet/ipv6/access_group (list)
|
f336640:c0:m15
|
def _set_access_group(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>",access_group.access_group, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT>', extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>', 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>': u'<STR_LIT>', 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.__access_group = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for access_group, mapped from YANG variable /interface/ethernet/ipv6/access_group (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_access_group is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_access_group() directly.
|
f336640:c0:m16
|
def _get_policy(self):
|
return self.__policy<EOL>
|
Getter method for policy, mapped from YANG variable /interface/ethernet/ipv6/policy (container)
YANG Description: Configure PBR
|
f336640:c0:m18
|
def _set_policy(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=policy.policy, 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>': 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.__policy = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for policy, mapped from YANG variable /interface/ethernet/ipv6/policy (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_policy is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_policy() directly.
YANG Description: Configure PBR
|
f336640:c0:m19
|
def _get_ipv6_nd_ra(self):
|
return self.__ipv6_nd_ra<EOL>
|
Getter method for ipv6_nd_ra, mapped from YANG variable /interface/ethernet/ipv6/ipv6_nd_ra (container)
|
f336640:c0:m21
|
def _set_ipv6_nd_ra(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=ipv6_nd_ra.ipv6_nd_ra, 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>': 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.__ipv6_nd_ra = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for ipv6_nd_ra, mapped from YANG variable /interface/ethernet/ipv6/ipv6_nd_ra (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_ipv6_nd_ra is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ipv6_nd_ra() directly.
|
f336640:c0:m22
|
def _get_intf_ipv6_router_isis(self):
|
return self.__intf_ipv6_router_isis<EOL>
|
Getter method for intf_ipv6_router_isis, mapped from YANG variable /interface/ethernet/ipv6/intf_ipv6_router_isis (container)
|
f336640:c0:m24
|
def _set_intf_ipv6_router_isis(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=intf_ipv6_router_isis.intf_ipv6_router_isis, 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>': 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.__intf_ipv6_router_isis = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for intf_ipv6_router_isis, mapped from YANG variable /interface/ethernet/ipv6/intf_ipv6_router_isis (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_intf_ipv6_router_isis is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_intf_ipv6_router_isis() directly.
|
f336640:c0:m25
|
def _get_ipv6_phy_intf_cmds(self):
|
return self.__ipv6_phy_intf_cmds<EOL>
|
Getter method for ipv6_phy_intf_cmds, mapped from YANG variable /interface/ethernet/ipv6/ipv6_phy_intf_cmds (container)
|
f336640:c0:m27
|
def _set_ipv6_phy_intf_cmds(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=ipv6_phy_intf_cmds.ipv6_phy_intf_cmds, 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>': 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.__ipv6_phy_intf_cmds = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for ipv6_phy_intf_cmds, mapped from YANG variable /interface/ethernet/ipv6/ipv6_phy_intf_cmds (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_ipv6_phy_intf_cmds is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ipv6_phy_intf_cmds() directly.
|
f336640:c0:m28
|
def _get_interface_ospfv3_conf(self):
|
return self.__interface_ospfv3_conf<EOL>
|
Getter method for interface_ospfv3_conf, mapped from YANG variable /interface/ethernet/ipv6/interface_ospfv3_conf (container)
YANG Description: Open Shortest Path First version 3 (OSPFv3)
|
f336640:c0:m30
|
def _set_interface_ospfv3_conf(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_ospfv3_conf.interface_ospfv3_conf, 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>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': 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.__interface_ospfv3_conf = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for interface_ospfv3_conf, mapped from YANG variable /interface/ethernet/ipv6/interface_ospfv3_conf (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_interface_ospfv3_conf is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_interface_ospfv3_conf() directly.
YANG Description: Open Shortest Path First version 3 (OSPFv3)
|
f336640:c0:m31
|
def _get_vrrpv3_group(self):
|
return self.__vrrpv3_group<EOL>
|
Getter method for vrrpv3_group, mapped from YANG variable /interface/ethernet/ipv6/vrrpv3_group (list)
YANG Description: Start vrrpv3 configuration
|
f336640:c0:m33
|
def _set_vrrpv3_group(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>",vrrpv3_group.vrrpv3_group, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT>', extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', 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>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', 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.__vrrpv3_group = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for vrrpv3_group, mapped from YANG variable /interface/ethernet/ipv6/vrrpv3_group (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_vrrpv3_group is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vrrpv3_group() directly.
YANG Description: Start vrrpv3 configuration
|
f336640:c0:m34
|
def _get_vrrpv3e_group(self):
|
return self.__vrrpv3e_group<EOL>
|
Getter method for vrrpv3e_group, mapped from YANG variable /interface/ethernet/ipv6/vrrpv3e_group (list)
|
f336640:c0:m36
|
def _set_vrrpv3e_group(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>",vrrpv3e_group.vrrpv3e_group, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT>', extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', 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>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', 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.__vrrpv3e_group = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for vrrpv3e_group, mapped from YANG variable /interface/ethernet/ipv6/vrrpv3e_group (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_vrrpv3e_group is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vrrpv3e_group() directly.
|
f336640:c0:m37
|
def _get_owner_priority(self):
|
return self.__owner_priority<EOL>
|
Getter method for owner_priority, mapped from YANG variable /interface/ethernet/ipv6/vrrpv3_group/owner/owner_priority (uint8)
YANG Description: IPv6 VRRP owner priority
|
f336641:c0:m3
|
def _set_owner_priority(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=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:8>), 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: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.__owner_priority = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for owner_priority, mapped from YANG variable /interface/ethernet/ipv6/vrrpv3_group/owner/owner_priority (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_owner_priority is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_owner_priority() directly.
YANG Description: IPv6 VRRP owner priority
|
f336641:c0:m4
|
def _get_owner_track_priority(self):
|
return self.__owner_track_priority<EOL>
|
Getter method for owner_track_priority, mapped from YANG variable /interface/ethernet/ipv6/vrrpv3_group/owner/owner_track_priority (uint8)
YANG Description: IPv6 VRRP owner track priority
|
f336641:c0:m6
|
def _set_owner_track_priority(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=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:8>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), default=RestrictedClassType(base_type=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:8>)(<NUM_LIT:0>), 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: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.__owner_track_priority = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for owner_track_priority, mapped from YANG variable /interface/ethernet/ipv6/vrrpv3_group/owner/owner_track_priority (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_owner_track_priority is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_owner_track_priority() directly.
YANG Description: IPv6 VRRP owner track priority
|
f336641:c0:m7
|
def _get_vrid(self):
|
return self.__vrid<EOL>
|
Getter method for vrid, mapped from YANG variable /interface/ethernet/ipv6/vrrpv3_group/vrid (vrid-type)
|
f336642:c0:m3
|
def _set_vrid(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=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:8>), 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}}, 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.__vrid = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for vrid, mapped from YANG variable /interface/ethernet/ipv6/vrrpv3_group/vrid (vrid-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_vrid is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vrid() directly.
|
f336642:c0:m4
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.