signature stringlengths 8 3.44k | body stringlengths 0 1.41M | docstring stringlengths 1 122k | id stringlengths 5 17 |
|---|---|---|---|
def _get_designated_port_id(self): | return self.__designated_port_id<EOL> | Getter method for designated_port_id, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_brief_info/output/spanning_tree_info/stp/port/designated_port_id (uint64)
YANG Description: Designated port id | f336770:c0:m33 |
def _set_designated_port_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=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, choice=(u'<STR_LIT>', u'<STR_LIT>'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, 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.__designated_port_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for designated_port_id, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_brief_info/output/spanning_tree_info/stp/port/designated_port_id (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_designated_port_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_designated_port_id() directly.
YANG Description: Designated port id | f336770:c0:m34 |
def _get_port_priority(self): | return self.__port_priority<EOL> | Getter method for port_priority, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_brief_info/output/spanning_tree_info/stp/port/port_priority (uint32)
YANG Description: Port priority | f336770:c0:m36 |
def _set_port_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=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, choice=(u'<STR_LIT>', u'<STR_LIT>'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, 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_priority = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for port_priority, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_brief_info/output/spanning_tree_info/stp/port/port_priority (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_port_priority is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_port_priority() directly.
YANG Description: Port priority | f336770:c0:m37 |
def _get_designated_bridge_id(self): | return self.__designated_bridge_id<EOL> | Getter method for designated_bridge_id, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_brief_info/output/spanning_tree_info/stp/port/designated_bridge_id (bridge-id-type)
YANG Description: Designated bridge Id | f336770:c0:m39 |
def _set_designated_bridge_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=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, choice=(u'<STR_LIT>', u'<STR_LIT>'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, 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.__designated_bridge_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for designated_bridge_id, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_brief_info/output/spanning_tree_info/stp/port/designated_bridge_id (bridge-id-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_designated_bridge_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_designated_bridge_id() directly.
YANG Description: Designated bridge Id | f336770:c0:m40 |
def _get_port_hello_time(self): | return self.__port_hello_time<EOL> | Getter method for port_hello_time, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_brief_info/output/spanning_tree_info/stp/port/port_hello_time (uint32)
YANG Description: Port hello time | f336770:c0:m42 |
def _set_port_hello_time(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, choice=(u'<STR_LIT>', u'<STR_LIT>'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, 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_hello_time = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for port_hello_time, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_brief_info/output/spanning_tree_info/stp/port/port_hello_time (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_port_hello_time is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_port_hello_time() directly.
YANG Description: Port hello time | f336770:c0:m43 |
def _get_forward_transitions_count(self): | return self.__forward_transitions_count<EOL> | Getter method for forward_transitions_count, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_brief_info/output/spanning_tree_info/stp/port/forward_transitions_count (uint32)
YANG Description: Number of forward transitions | f336770:c0:m45 |
def _set_forward_transitions_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=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, choice=(u'<STR_LIT>', u'<STR_LIT>'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, 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.__forward_transitions_count = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for forward_transitions_count, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_brief_info/output/spanning_tree_info/stp/port/forward_transitions_count (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_forward_transitions_count is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_forward_transitions_count() directly.
YANG Description: Number of forward transitions | f336770:c0:m46 |
def _get_received_stp_type(self): | return self.__received_stp_type<EOL> | Getter method for received_stp_type, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_brief_info/output/spanning_tree_info/stp/port/received_stp_type (stp-type)
YANG Description: Received (rx) stp type | f336770:c0:m48 |
def _set_received_stp_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:none>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:3>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:4>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:6>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:5>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, choice=(u'<STR_LIT>', u'<STR_LIT>'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, 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.__received_stp_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for received_stp_type, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_brief_info/output/spanning_tree_info/stp/port/received_stp_type (stp-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_received_stp_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_received_stp_type() directly.
YANG Description: Received (rx) stp type | f336770:c0:m49 |
def _get_transmitted_stp_type(self): | return self.__transmitted_stp_type<EOL> | Getter method for transmitted_stp_type, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_brief_info/output/spanning_tree_info/stp/port/transmitted_stp_type (stp-type)
YANG Description: Transmitted (tx) stp type | f336770:c0:m51 |
def _set_transmitted_stp_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:none>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:3>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:4>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:6>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:5>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, choice=(u'<STR_LIT>', u'<STR_LIT>'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, 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.__transmitted_stp_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for transmitted_stp_type, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_brief_info/output/spanning_tree_info/stp/port/transmitted_stp_type (stp-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_transmitted_stp_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_transmitted_stp_type() directly.
YANG Description: Transmitted (tx) stp type | f336770:c0:m52 |
def _get_edge_port(self): | return self.__edge_port<EOL> | Getter method for edge_port, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_brief_info/output/spanning_tree_info/stp/port/edge_port (on-off-type)
YANG Description: Edge Port mode | f336770:c0:m54 |
def _set_edge_port(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:2>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, choice=(u'<STR_LIT>', u'<STR_LIT>'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, 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.__edge_port = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for edge_port, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_brief_info/output/spanning_tree_info/stp/port/edge_port (on-off-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_edge_port is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_edge_port() directly.
YANG Description: Edge Port mode | f336770:c0:m55 |
def _get_auto_edge(self): | return self.__auto_edge<EOL> | Getter method for auto_edge, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_brief_info/output/spanning_tree_info/stp/port/auto_edge (yes-no-type)
YANG Description: Auto Edge | f336770:c0:m57 |
def _set_auto_edge(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:yes>': {'<STR_LIT:value>': <NUM_LIT:2>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, choice=(u'<STR_LIT>', u'<STR_LIT>'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, 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.__auto_edge = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for auto_edge, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_brief_info/output/spanning_tree_info/stp/port/auto_edge (yes-no-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_auto_edge is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_auto_edge() directly.
YANG Description: Auto Edge | f336770:c0:m58 |
def _get_admin_edge(self): | return self.__admin_edge<EOL> | Getter method for admin_edge, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_brief_info/output/spanning_tree_info/stp/port/admin_edge (yes-no-type)
YANG Description: Admin Edge | f336770:c0:m60 |
def _set_admin_edge(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:yes>': {'<STR_LIT:value>': <NUM_LIT:2>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, choice=(u'<STR_LIT>', u'<STR_LIT>'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, 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.__admin_edge = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for admin_edge, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_brief_info/output/spanning_tree_info/stp/port/admin_edge (yes-no-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_admin_edge is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_admin_edge() directly.
YANG Description: Admin Edge | f336770:c0:m61 |
def _get_edge_delay(self): | return self.__edge_delay<EOL> | Getter method for edge_delay, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_brief_info/output/spanning_tree_info/stp/port/edge_delay (uint32)
YANG Description: Edge delay | f336770:c0:m63 |
def _set_edge_delay(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, choice=(u'<STR_LIT>', u'<STR_LIT>'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, 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.__edge_delay = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for edge_delay, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_brief_info/output/spanning_tree_info/stp/port/edge_delay (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_edge_delay is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_edge_delay() directly.
YANG Description: Edge delay | f336770:c0:m64 |
def _get_configured_root_guard(self): | return self.__configured_root_guard<EOL> | Getter method for configured_root_guard, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_brief_info/output/spanning_tree_info/stp/port/configured_root_guard (on-off-type)
YANG Description: Configured root guard | f336770:c0:m66 |
def _set_configured_root_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=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, choice=(u'<STR_LIT>', u'<STR_LIT>'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, 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.__configured_root_guard = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for configured_root_guard, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_brief_info/output/spanning_tree_info/stp/port/configured_root_guard (on-off-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_configured_root_guard is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_configured_root_guard() directly.
YANG Description: Configured root guard | f336770:c0:m67 |
def _get_oper_root_guard(self): | return self.__oper_root_guard<EOL> | Getter method for oper_root_guard, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_brief_info/output/spanning_tree_info/stp/port/oper_root_guard (on-off-type)
YANG Description: Operational root guard | f336770:c0:m69 |
def _set_oper_root_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=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, choice=(u'<STR_LIT>', u'<STR_LIT>'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, 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.__oper_root_guard = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for oper_root_guard, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_brief_info/output/spanning_tree_info/stp/port/oper_root_guard (on-off-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_oper_root_guard is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_oper_root_guard() directly.
YANG Description: Operational root guard | f336770:c0:m70 |
def _get_boundary_port(self): | return self.__boundary_port<EOL> | Getter method for boundary_port, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_brief_info/output/spanning_tree_info/stp/port/boundary_port (yes-no-type)
YANG Description: Is boundary | f336770:c0:m72 |
def _set_boundary_port(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:yes>': {'<STR_LIT:value>': <NUM_LIT:2>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, choice=(u'<STR_LIT>', u'<STR_LIT>'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, 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.__boundary_port = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for boundary_port, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_brief_info/output/spanning_tree_info/stp/port/boundary_port (yes-no-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_boundary_port is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_boundary_port() directly.
YANG Description: Is boundary | f336770:c0:m73 |
def _get_oper_bpdu_guard(self): | return self.__oper_bpdu_guard<EOL> | Getter method for oper_bpdu_guard, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_brief_info/output/spanning_tree_info/stp/port/oper_bpdu_guard (on-off-type)
YANG Description: Operational BPDU guard | f336770:c0:m75 |
def _set_oper_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=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, choice=(u'<STR_LIT>', u'<STR_LIT>'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, 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.__oper_bpdu_guard = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for oper_bpdu_guard, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_brief_info/output/spanning_tree_info/stp/port/oper_bpdu_guard (on-off-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_oper_bpdu_guard is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_oper_bpdu_guard() directly.
YANG Description: Operational BPDU guard | f336770:c0:m76 |
def _get_link_type(self): | return self.__link_type<EOL> | Getter method for link_type, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_brief_info/output/spanning_tree_info/stp/port/link_type (stp-link-type) | f336770:c0:m78 |
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>': {'<STR_LIT:value>': <NUM_LIT:2>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, choice=(u'<STR_LIT>', u'<STR_LIT>'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, 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 /brocade_xstp_ext_rpc/get_stp_brief_info/output/spanning_tree_info/stp/port/link_type (stp-link-type)
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. | f336770:c0:m79 |
def _get_rx_bpdu_count(self): | return self.__rx_bpdu_count<EOL> | Getter method for rx_bpdu_count, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_brief_info/output/spanning_tree_info/stp/port/rx_bpdu_count (uint64)
YANG Description: Received Bpdu count | f336770:c0:m81 |
def _set_rx_bpdu_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=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, choice=(u'<STR_LIT>', u'<STR_LIT>'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, 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.__rx_bpdu_count = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rx_bpdu_count, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_brief_info/output/spanning_tree_info/stp/port/rx_bpdu_count (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_rx_bpdu_count is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rx_bpdu_count() directly.
YANG Description: Received Bpdu count | f336770:c0:m82 |
def _get_tx_bpdu_count(self): | return self.__tx_bpdu_count<EOL> | Getter method for tx_bpdu_count, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_brief_info/output/spanning_tree_info/stp/port/tx_bpdu_count (uint64)
YANG Description: Transmitted Bpdu count | f336770:c0:m84 |
def _set_tx_bpdu_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=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, choice=(u'<STR_LIT>', u'<STR_LIT>'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, 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.__tx_bpdu_count = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for tx_bpdu_count, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_brief_info/output/spanning_tree_info/stp/port/tx_bpdu_count (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_tx_bpdu_count is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tx_bpdu_count() directly.
YANG Description: Transmitted Bpdu count | f336770:c0:m85 |
def _get_interface_type(self): | return self.__interface_type<EOL> | Getter method for interface_type, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_mst_detail/output/cist/port/interface_type (enumeration)
YANG Description: The type of the interface. An 'unknown' type
represents error scenario and should not be used. | f336771:c0:m3 |
def _set_interface_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:8>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:7>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:12>}, 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:11>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:10>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:6>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, 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.__interface_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for interface_type, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_mst_detail/output/cist/port/interface_type (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_interface_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_interface_type() directly.
YANG Description: The type of the interface. An 'unknown' type
represents error scenario and should not be used. | f336771:c0:m4 |
def _get_interface_name(self): | return self.__interface_name<EOL> | Getter method for interface_name, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_mst_detail/output/cist/port/interface_name (union)
YANG Description: The Interface value. The interface value is always
interpreted within the context of the value of
'interface-type' leaf:
interface-type interface-name
----------------- --------------------
ethernet slot/port
port-channel Port channel ID
l2vlan Vlan ID
loopback Loopback ID
ve VE Interface ID
unknown Zero-length string.
The value of an 'interface-name' must always be
consistent with the value of the associated
'interface-type'. Attempts to set an interface-name
to a value inconsistent with the associated
'interface-type' must fail with an error. | f336771:c0:m6 |
def _set_interface_name(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=[RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>', '<STR_LIT>': [u'<STR_LIT>']}),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>']}),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=False, 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.__interface_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for interface_name, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_mst_detail/output/cist/port/interface_name (union)
If this variable is read-only (config: false) in the
source YANG file, then _set_interface_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_interface_name() directly.
YANG Description: The Interface value. The interface value is always
interpreted within the context of the value of
'interface-type' leaf:
interface-type interface-name
----------------- --------------------
ethernet slot/port
port-channel Port channel ID
l2vlan Vlan ID
loopback Loopback ID
ve VE Interface ID
unknown Zero-length string.
The value of an 'interface-name' must always be
consistent with the value of the associated
'interface-type'. Attempts to set an interface-name
to a value inconsistent with the associated
'interface-type' must fail with an error. | f336771:c0:m7 |
def _get_spanningtree_enabled(self): | return self.__spanningtree_enabled<EOL> | Getter method for spanningtree_enabled, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_mst_detail/output/cist/port/spanningtree_enabled (boolean)
YANG Description: Is spanning tree enabled | f336771:c0:m9 |
def _set_spanningtree_enabled(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=False, 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.__spanningtree_enabled = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for spanningtree_enabled, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_mst_detail/output/cist/port/spanningtree_enabled (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_spanningtree_enabled is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_spanningtree_enabled() directly.
YANG Description: Is spanning tree enabled | f336771:c0:m10 |
def _get_if_index(self): | return self.__if_index<EOL> | Getter method for if_index, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_mst_detail/output/cist/port/if_index (uint64)
YANG Description: Interface index | f336771:c0:m12 |
def _set_if_index(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, 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.__if_index = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for if_index, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_mst_detail/output/cist/port/if_index (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_if_index is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_if_index() directly.
YANG Description: Interface index | f336771:c0:m13 |
def _get_interface_id(self): | return self.__interface_id<EOL> | Getter method for interface_id, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_mst_detail/output/cist/port/interface_id (uint64)
YANG Description: Interface id | f336771:c0:m15 |
def _set_interface_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=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, 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_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for interface_id, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_mst_detail/output/cist/port/interface_id (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_interface_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_interface_id() directly.
YANG Description: Interface id | f336771:c0:m16 |
def _get_if_role(self): | return self.__if_role<EOL> | Getter method for if_role, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_mst_detail/output/cist/port/if_role (stp-port-role)
YANG Description: Interface role | f336771:c0:m18 |
def _set_if_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=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:5>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:4>}, 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:7>}, u'<STR_LIT:error>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT:root>': {'<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=False, 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.__if_role = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for if_role, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_mst_detail/output/cist/port/if_role (stp-port-role)
If this variable is read-only (config: false) in the
source YANG file, then _set_if_role is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_if_role() directly.
YANG Description: Interface role | f336771:c0:m19 |
def _get_if_state(self): | return self.__if_state<EOL> | Getter method for if_state, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_mst_detail/output/cist/port/if_state (stp-port-state)
YANG Description: Interface state | f336771:c0:m21 |
def _set_if_state(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:4>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:7>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:5>}, u'<STR_LIT:error>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:6>}, 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=False, 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.__if_state = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for if_state, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_mst_detail/output/cist/port/if_state (stp-port-state)
If this variable is read-only (config: false) in the
source YANG file, then _set_if_state is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_if_state() directly.
YANG Description: Interface state | f336771:c0:m22 |
def _get_external_path_cost(self): | return self.__external_path_cost<EOL> | Getter method for external_path_cost, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_mst_detail/output/cist/port/external_path_cost (uint32)
YANG Description: Designated external path cost | f336771:c0:m24 |
def _set_external_path_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=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, 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.__external_path_cost = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for external_path_cost, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_mst_detail/output/cist/port/external_path_cost (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_external_path_cost is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_external_path_cost() directly.
YANG Description: Designated external path cost | f336771:c0:m25 |
def _get_internal_path_cost(self): | return self.__internal_path_cost<EOL> | Getter method for internal_path_cost, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_mst_detail/output/cist/port/internal_path_cost (uint32)
YANG Description: Designated internal path cost | f336771:c0:m27 |
def _set_internal_path_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=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, 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.__internal_path_cost = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for internal_path_cost, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_mst_detail/output/cist/port/internal_path_cost (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_internal_path_cost is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_internal_path_cost() directly.
YANG Description: Designated internal path cost | f336771:c0:m28 |
def _get_configured_path_cost(self): | return self.__configured_path_cost<EOL> | Getter method for configured_path_cost, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_mst_detail/output/cist/port/configured_path_cost (uint32)
YANG Description: Configured path cost | f336771:c0:m30 |
def _set_configured_path_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=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, 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.__configured_path_cost = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for configured_path_cost, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_mst_detail/output/cist/port/configured_path_cost (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_configured_path_cost is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_configured_path_cost() directly.
YANG Description: Configured path cost | f336771:c0:m31 |
def _get_designated_port_id(self): | return self.__designated_port_id<EOL> | Getter method for designated_port_id, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_mst_detail/output/cist/port/designated_port_id (uint64)
YANG Description: Designated port id | f336771:c0:m33 |
def _set_designated_port_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=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, 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.__designated_port_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for designated_port_id, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_mst_detail/output/cist/port/designated_port_id (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_designated_port_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_designated_port_id() directly.
YANG Description: Designated port id | f336771:c0:m34 |
def _get_port_priority(self): | return self.__port_priority<EOL> | Getter method for port_priority, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_mst_detail/output/cist/port/port_priority (uint32)
YANG Description: Port priority | f336771:c0:m36 |
def _set_port_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=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, 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_priority = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for port_priority, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_mst_detail/output/cist/port/port_priority (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_port_priority is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_port_priority() directly.
YANG Description: Port priority | f336771:c0:m37 |
def _get_designated_bridge_id(self): | return self.__designated_bridge_id<EOL> | Getter method for designated_bridge_id, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_mst_detail/output/cist/port/designated_bridge_id (bridge-id-type)
YANG Description: Designated bridge Id | f336771:c0:m39 |
def _set_designated_bridge_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=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, 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.__designated_bridge_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for designated_bridge_id, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_mst_detail/output/cist/port/designated_bridge_id (bridge-id-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_designated_bridge_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_designated_bridge_id() directly.
YANG Description: Designated bridge Id | f336771:c0:m40 |
def _get_port_hello_time(self): | return self.__port_hello_time<EOL> | Getter method for port_hello_time, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_mst_detail/output/cist/port/port_hello_time (uint32)
YANG Description: Port hello time | f336771:c0:m42 |
def _set_port_hello_time(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, 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_hello_time = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for port_hello_time, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_mst_detail/output/cist/port/port_hello_time (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_port_hello_time is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_port_hello_time() directly.
YANG Description: Port hello time | f336771:c0:m43 |
def _get_forward_transitions_count(self): | return self.__forward_transitions_count<EOL> | Getter method for forward_transitions_count, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_mst_detail/output/cist/port/forward_transitions_count (uint32)
YANG Description: Number of forward transitions | f336771:c0:m45 |
def _set_forward_transitions_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=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, 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.__forward_transitions_count = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for forward_transitions_count, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_mst_detail/output/cist/port/forward_transitions_count (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_forward_transitions_count is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_forward_transitions_count() directly.
YANG Description: Number of forward transitions | f336771:c0:m46 |
def _get_received_stp_type(self): | return self.__received_stp_type<EOL> | Getter method for received_stp_type, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_mst_detail/output/cist/port/received_stp_type (stp-type)
YANG Description: Received (rx) stp type | f336771:c0:m48 |
def _set_received_stp_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:none>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:3>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:4>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:6>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:5>}, 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=False, 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.__received_stp_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for received_stp_type, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_mst_detail/output/cist/port/received_stp_type (stp-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_received_stp_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_received_stp_type() directly.
YANG Description: Received (rx) stp type | f336771:c0:m49 |
def _get_transmitted_stp_type(self): | return self.__transmitted_stp_type<EOL> | Getter method for transmitted_stp_type, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_mst_detail/output/cist/port/transmitted_stp_type (stp-type)
YANG Description: Transmitted (tx) stp type | f336771:c0:m51 |
def _set_transmitted_stp_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:none>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:3>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:4>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:6>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:5>}, 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=False, 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.__transmitted_stp_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for transmitted_stp_type, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_mst_detail/output/cist/port/transmitted_stp_type (stp-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_transmitted_stp_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_transmitted_stp_type() directly.
YANG Description: Transmitted (tx) stp type | f336771:c0:m52 |
def _get_edge_port(self): | return self.__edge_port<EOL> | Getter method for edge_port, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_mst_detail/output/cist/port/edge_port (on-off-type)
YANG Description: Edge Port mode | f336771:c0:m54 |
def _set_edge_port(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:2>}, 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=False, 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.__edge_port = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for edge_port, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_mst_detail/output/cist/port/edge_port (on-off-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_edge_port is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_edge_port() directly.
YANG Description: Edge Port mode | f336771:c0:m55 |
def _get_auto_edge(self): | return self.__auto_edge<EOL> | Getter method for auto_edge, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_mst_detail/output/cist/port/auto_edge (yes-no-type)
YANG Description: Auto Edge | f336771:c0:m57 |
def _set_auto_edge(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:yes>': {'<STR_LIT:value>': <NUM_LIT:2>}, 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=False, 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.__auto_edge = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for auto_edge, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_mst_detail/output/cist/port/auto_edge (yes-no-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_auto_edge is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_auto_edge() directly.
YANG Description: Auto Edge | f336771:c0:m58 |
def _get_admin_edge(self): | return self.__admin_edge<EOL> | Getter method for admin_edge, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_mst_detail/output/cist/port/admin_edge (yes-no-type)
YANG Description: Admin Edge | f336771:c0:m60 |
def _set_admin_edge(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:yes>': {'<STR_LIT:value>': <NUM_LIT:2>}, 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=False, 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.__admin_edge = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for admin_edge, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_mst_detail/output/cist/port/admin_edge (yes-no-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_admin_edge is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_admin_edge() directly.
YANG Description: Admin Edge | f336771:c0:m61 |
def _get_edge_delay(self): | return self.__edge_delay<EOL> | Getter method for edge_delay, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_mst_detail/output/cist/port/edge_delay (uint32)
YANG Description: Edge delay | f336771:c0:m63 |
def _set_edge_delay(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, 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.__edge_delay = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for edge_delay, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_mst_detail/output/cist/port/edge_delay (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_edge_delay is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_edge_delay() directly.
YANG Description: Edge delay | f336771:c0:m64 |
def _get_configured_root_guard(self): | return self.__configured_root_guard<EOL> | Getter method for configured_root_guard, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_mst_detail/output/cist/port/configured_root_guard (on-off-type)
YANG Description: Configured root guard | f336771:c0:m66 |
def _set_configured_root_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=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}, 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=False, 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.__configured_root_guard = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for configured_root_guard, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_mst_detail/output/cist/port/configured_root_guard (on-off-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_configured_root_guard is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_configured_root_guard() directly.
YANG Description: Configured root guard | f336771:c0:m67 |
def _get_oper_root_guard(self): | return self.__oper_root_guard<EOL> | Getter method for oper_root_guard, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_mst_detail/output/cist/port/oper_root_guard (on-off-type)
YANG Description: Operational root guard | f336771:c0:m69 |
def _set_oper_root_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=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}, 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=False, 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.__oper_root_guard = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for oper_root_guard, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_mst_detail/output/cist/port/oper_root_guard (on-off-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_oper_root_guard is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_oper_root_guard() directly.
YANG Description: Operational root guard | f336771:c0:m70 |
def _get_boundary_port(self): | return self.__boundary_port<EOL> | Getter method for boundary_port, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_mst_detail/output/cist/port/boundary_port (yes-no-type)
YANG Description: Is boundary | f336771:c0:m72 |
def _set_boundary_port(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:yes>': {'<STR_LIT:value>': <NUM_LIT:2>}, 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=False, 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.__boundary_port = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for boundary_port, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_mst_detail/output/cist/port/boundary_port (yes-no-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_boundary_port is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_boundary_port() directly.
YANG Description: Is boundary | f336771:c0:m73 |
def _get_oper_bpdu_guard(self): | return self.__oper_bpdu_guard<EOL> | Getter method for oper_bpdu_guard, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_mst_detail/output/cist/port/oper_bpdu_guard (on-off-type)
YANG Description: Operational BPDU guard | f336771:c0:m75 |
def _set_oper_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=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}, 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=False, 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.__oper_bpdu_guard = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for oper_bpdu_guard, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_mst_detail/output/cist/port/oper_bpdu_guard (on-off-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_oper_bpdu_guard is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_oper_bpdu_guard() directly.
YANG Description: Operational BPDU guard | f336771:c0:m76 |
def _get_link_type(self): | return self.__link_type<EOL> | Getter method for link_type, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_mst_detail/output/cist/port/link_type (stp-link-type) | f336771:c0:m78 |
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>': {'<STR_LIT:value>': <NUM_LIT:2>}, 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=False, 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 /brocade_xstp_ext_rpc/get_stp_mst_detail/output/cist/port/link_type (stp-link-type)
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. | f336771:c0:m79 |
def _get_rx_bpdu_count(self): | return self.__rx_bpdu_count<EOL> | Getter method for rx_bpdu_count, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_mst_detail/output/cist/port/rx_bpdu_count (uint64)
YANG Description: Received Bpdu count | f336771:c0:m81 |
def _set_rx_bpdu_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=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, 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.__rx_bpdu_count = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rx_bpdu_count, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_mst_detail/output/cist/port/rx_bpdu_count (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_rx_bpdu_count is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rx_bpdu_count() directly.
YANG Description: Received Bpdu count | f336771:c0:m82 |
def _get_tx_bpdu_count(self): | return self.__tx_bpdu_count<EOL> | Getter method for tx_bpdu_count, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_mst_detail/output/cist/port/tx_bpdu_count (uint64)
YANG Description: Transmitted Bpdu count | f336771:c0:m84 |
def _set_tx_bpdu_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=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, 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.__tx_bpdu_count = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for tx_bpdu_count, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_mst_detail/output/cist/port/tx_bpdu_count (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_tx_bpdu_count is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tx_bpdu_count() directly.
YANG Description: Transmitted Bpdu count | f336771:c0:m85 |
def _get_interface_type(self): | return self.__interface_type<EOL> | Getter method for interface_type, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_mst_detail/output/msti/port/interface_type (enumeration)
YANG Description: The type of the interface. An 'unknown' type
represents error scenario and should not be used. | f336772:c0:m3 |
def _set_interface_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:8>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:7>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:12>}, 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:11>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:10>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:6>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, 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.__interface_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for interface_type, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_mst_detail/output/msti/port/interface_type (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_interface_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_interface_type() directly.
YANG Description: The type of the interface. An 'unknown' type
represents error scenario and should not be used. | f336772:c0:m4 |
def _get_interface_name(self): | return self.__interface_name<EOL> | Getter method for interface_name, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_mst_detail/output/msti/port/interface_name (union)
YANG Description: The Interface value. The interface value is always
interpreted within the context of the value of
'interface-type' leaf:
interface-type interface-name
----------------- --------------------
ethernet slot/port
port-channel Port channel ID
l2vlan Vlan ID
loopback Loopback ID
ve VE Interface ID
unknown Zero-length string.
The value of an 'interface-name' must always be
consistent with the value of the associated
'interface-type'. Attempts to set an interface-name
to a value inconsistent with the associated
'interface-type' must fail with an error. | f336772:c0:m6 |
def _set_interface_name(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=[RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>', '<STR_LIT>': [u'<STR_LIT>']}),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>']}),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=False, 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.__interface_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for interface_name, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_mst_detail/output/msti/port/interface_name (union)
If this variable is read-only (config: false) in the
source YANG file, then _set_interface_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_interface_name() directly.
YANG Description: The Interface value. The interface value is always
interpreted within the context of the value of
'interface-type' leaf:
interface-type interface-name
----------------- --------------------
ethernet slot/port
port-channel Port channel ID
l2vlan Vlan ID
loopback Loopback ID
ve VE Interface ID
unknown Zero-length string.
The value of an 'interface-name' must always be
consistent with the value of the associated
'interface-type'. Attempts to set an interface-name
to a value inconsistent with the associated
'interface-type' must fail with an error. | f336772:c0:m7 |
def _get_spanningtree_enabled(self): | return self.__spanningtree_enabled<EOL> | Getter method for spanningtree_enabled, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_mst_detail/output/msti/port/spanningtree_enabled (boolean)
YANG Description: Is spanning tree enabled | f336772:c0:m9 |
def _set_spanningtree_enabled(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=False, 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.__spanningtree_enabled = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for spanningtree_enabled, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_mst_detail/output/msti/port/spanningtree_enabled (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_spanningtree_enabled is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_spanningtree_enabled() directly.
YANG Description: Is spanning tree enabled | f336772:c0:m10 |
def _get_if_index(self): | return self.__if_index<EOL> | Getter method for if_index, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_mst_detail/output/msti/port/if_index (uint64)
YANG Description: Interface index | f336772:c0:m12 |
def _set_if_index(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, 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.__if_index = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for if_index, mapped from YANG variable /brocade_xstp_ext_rpc/get_stp_mst_detail/output/msti/port/if_index (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_if_index is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_if_index() directly.
YANG Description: Interface index | f336772:c0:m13 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.