signature
stringlengths 8
3.44k
| body
stringlengths 0
1.41M
| docstring
stringlengths 1
122k
| id
stringlengths 5
17
|
|---|---|---|---|
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/msti/port/interface_id (uint64)
YANG Description: Interface id | f336772: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/msti/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 | f336772: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/msti/port/if_role (stp-port-role)
YANG Description: Interface role | f336772: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/msti/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 | f336772: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/msti/port/if_state (stp-port-state)
YANG Description: Interface state | f336772: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/msti/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 | f336772: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/msti/port/external_path_cost (uint32)
YANG Description: Designated external path cost | f336772: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/msti/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 | f336772: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/msti/port/internal_path_cost (uint32)
YANG Description: Designated internal path cost | f336772: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/msti/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 | f336772: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/msti/port/configured_path_cost (uint32)
YANG Description: Configured path cost | f336772: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/msti/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 | f336772: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/msti/port/designated_port_id (uint64)
YANG Description: Designated port id | f336772: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/msti/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 | f336772: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/msti/port/port_priority (uint32)
YANG Description: Port priority | f336772: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/msti/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 | f336772: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/msti/port/designated_bridge_id (bridge-id-type)
YANG Description: Designated bridge Id | f336772: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/msti/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 | f336772: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/msti/port/port_hello_time (uint32)
YANG Description: Port hello time | f336772: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/msti/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 | f336772: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/msti/port/forward_transitions_count (uint32)
YANG Description: Number of forward transitions | f336772: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/msti/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 | f336772: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/msti/port/received_stp_type (stp-type)
YANG Description: Received (rx) stp type | f336772: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/msti/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 | f336772: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/msti/port/transmitted_stp_type (stp-type)
YANG Description: Transmitted (tx) stp type | f336772: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/msti/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 | f336772: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/msti/port/edge_port (on-off-type)
YANG Description: Edge Port mode | f336772: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/msti/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 | f336772: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/msti/port/auto_edge (yes-no-type)
YANG Description: Auto Edge | f336772: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/msti/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 | f336772: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/msti/port/admin_edge (yes-no-type)
YANG Description: Admin Edge | f336772: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/msti/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 | f336772: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/msti/port/edge_delay (uint32)
YANG Description: Edge delay | f336772: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/msti/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 | f336772: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/msti/port/configured_root_guard (on-off-type)
YANG Description: Configured root guard | f336772: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/msti/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 | f336772: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/msti/port/oper_root_guard (on-off-type)
YANG Description: Operational root guard | f336772: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/msti/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 | f336772: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/msti/port/boundary_port (yes-no-type)
YANG Description: Is boundary | f336772: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/msti/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 | f336772: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/msti/port/oper_bpdu_guard (on-off-type)
YANG Description: Operational BPDU guard | f336772: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/msti/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 | f336772: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/msti/port/link_type (stp-link-type) | f336772: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/msti/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. | f336772: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/msti/port/rx_bpdu_count (uint64)
YANG Description: Received Bpdu count | f336772: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/msti/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 | f336772: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/msti/port/tx_bpdu_count (uint64)
YANG Description: Transmitted Bpdu count | f336772: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/msti/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 | f336772:c0:m85 |
def _get_interface_type(self): | return self.__interface_type<EOL> | Getter method for interface_type, mapped from YANG variable /brocade_lag_rpc/get_portchannel_info_by_intf/input/interface_type (enumeration)
YANG Description: The type of the interface. An 'unknown' type
represents error scenario and should not be used. | f336773: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_lag_rpc/get_portchannel_info_by_intf/input/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. | f336773:c0:m4 |
def _get_interface_name(self): | return self.__interface_name<EOL> | Getter method for interface_name, mapped from YANG variable /brocade_lag_rpc/get_portchannel_info_by_intf/input/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. | f336773: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_lag_rpc/get_portchannel_info_by_intf/input/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. | f336773:c0:m7 |
def _get_interface_type(self): | return self.__interface_type<EOL> | Getter method for interface_type, mapped from YANG variable /brocade_lag_rpc/get_portchannel_info_by_intf/output/lacp/interface_type (enumeration)
YANG Description: The type of the interface. An 'unknown' type
represents error scenario and should not be used. | f336774: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_lag_rpc/get_portchannel_info_by_intf/output/lacp/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. | f336774:c0:m4 |
def _get_interface_name(self): | return self.__interface_name<EOL> | Getter method for interface_name, mapped from YANG variable /brocade_lag_rpc/get_portchannel_info_by_intf/output/lacp/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. | f336774: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_lag_rpc/get_portchannel_info_by_intf/output/lacp/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. | f336774:c0:m7 |
def _get_actor_port(self): | return self.__actor_port<EOL> | Getter method for actor_port, mapped from YANG variable /brocade_lag_rpc/get_portchannel_info_by_intf/output/lacp/actor_port (uint64)
YANG Description: The actor port number | f336774:c0:m9 |
def _set_actor_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=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.__actor_port = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for actor_port, mapped from YANG variable /brocade_lag_rpc/get_portchannel_info_by_intf/output/lacp/actor_port (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_actor_port is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_actor_port() directly.
YANG Description: The actor port number | f336774:c0:m10 |
def _get_admin_key(self): | return self.__admin_key<EOL> | Getter method for admin_key, mapped from YANG variable /brocade_lag_rpc/get_portchannel_info_by_intf/output/lacp/admin_key (lacp-key)
YANG Description: The Admin key | f336774:c0:m12 |
def _set_admin_key(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=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_key = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for admin_key, mapped from YANG variable /brocade_lag_rpc/get_portchannel_info_by_intf/output/lacp/admin_key (lacp-key)
If this variable is read-only (config: false) in the
source YANG file, then _set_admin_key is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_admin_key() directly.
YANG Description: The Admin key | f336774:c0:m13 |
def _get_oper_key(self): | return self.__oper_key<EOL> | Getter method for oper_key, mapped from YANG variable /brocade_lag_rpc/get_portchannel_info_by_intf/output/lacp/oper_key (lacp-key)
YANG Description: The Opertional key | f336774:c0:m15 |
def _set_oper_key(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=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_key = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for oper_key, mapped from YANG variable /brocade_lag_rpc/get_portchannel_info_by_intf/output/lacp/oper_key (lacp-key)
If this variable is read-only (config: false) in the
source YANG file, then _set_oper_key is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_oper_key() directly.
YANG Description: The Opertional key | f336774:c0:m16 |
def _get_actor_system_id(self): | return self.__actor_system_id<EOL> | Getter method for actor_system_id, mapped from YANG variable /brocade_lag_rpc/get_portchannel_info_by_intf/output/lacp/actor_system_id (yang:mac-address)
YANG Description: The Actor system id | f336774:c0:m18 |
def _set_actor_system_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=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=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.__actor_system_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for actor_system_id, mapped from YANG variable /brocade_lag_rpc/get_portchannel_info_by_intf/output/lacp/actor_system_id (yang:mac-address)
If this variable is read-only (config: false) in the
source YANG file, then _set_actor_system_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_actor_system_id() directly.
YANG Description: The Actor system id | f336774:c0:m19 |
def _get_partner_system_id(self): | return self.__partner_system_id<EOL> | Getter method for partner_system_id, mapped from YANG variable /brocade_lag_rpc/get_portchannel_info_by_intf/output/lacp/partner_system_id (yang:mac-address)
YANG Description: The Partner system id | f336774:c0:m21 |
def _set_partner_system_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=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=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.__partner_system_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for partner_system_id, mapped from YANG variable /brocade_lag_rpc/get_portchannel_info_by_intf/output/lacp/partner_system_id (yang:mac-address)
If this variable is read-only (config: false) in the
source YANG file, then _set_partner_system_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_partner_system_id() directly.
YANG Description: The Partner system id | f336774:c0:m22 |
def _get_system_priority(self): | return self.__system_priority<EOL> | Getter method for system_priority, mapped from YANG variable /brocade_lag_rpc/get_portchannel_info_by_intf/output/lacp/system_priority (uint32)
YANG Description: The System Priority | f336774:c0:m24 |
def _set_system_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=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.__system_priority = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for system_priority, mapped from YANG variable /brocade_lag_rpc/get_portchannel_info_by_intf/output/lacp/system_priority (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_system_priority is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_system_priority() directly.
YANG Description: The System Priority | f336774:c0:m25 |
def _get_partner_oper_priority(self): | return self.__partner_oper_priority<EOL> | Getter method for partner_oper_priority, mapped from YANG variable /brocade_lag_rpc/get_portchannel_info_by_intf/output/lacp/partner_oper_priority (uint32)
YANG Description: The partner operational priority | f336774:c0:m27 |
def _set_partner_oper_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=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.__partner_oper_priority = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for partner_oper_priority, mapped from YANG variable /brocade_lag_rpc/get_portchannel_info_by_intf/output/lacp/partner_oper_priority (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_partner_oper_priority is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_partner_oper_priority() directly.
YANG Description: The partner operational priority | f336774:c0:m28 |
def _get_actor_priority(self): | return self.__actor_priority<EOL> | Getter method for actor_priority, mapped from YANG variable /brocade_lag_rpc/get_portchannel_info_by_intf/output/lacp/actor_priority (uint32)
YANG Description: The Actor Priority | f336774:c0:m30 |
def _set_actor_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=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.__actor_priority = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for actor_priority, mapped from YANG variable /brocade_lag_rpc/get_portchannel_info_by_intf/output/lacp/actor_priority (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_actor_priority is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_actor_priority() directly.
YANG Description: The Actor Priority | f336774:c0:m31 |
def _get_receive_machine_state(self): | return self.__receive_machine_state<EOL> | Getter method for receive_machine_state, mapped from YANG variable /brocade_lag_rpc/get_portchannel_info_by_intf/output/lacp/receive_machine_state (enumeration)
YANG Description: The state of the 'Receive Machine' | f336774:c0:m33 |
def _set_receive_machine_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:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:5>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:8>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:7>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:3>}, 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, 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.__receive_machine_state = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for receive_machine_state, mapped from YANG variable /brocade_lag_rpc/get_portchannel_info_by_intf/output/lacp/receive_machine_state (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_receive_machine_state is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_receive_machine_state() directly.
YANG Description: The state of the 'Receive Machine' | f336774:c0:m34 |
def _get_periodic_transmission_machine_state(self): | return self.__periodic_transmission_machine_state<EOL> | Getter method for periodic_transmission_machine_state, mapped from YANG variable /brocade_lag_rpc/get_portchannel_info_by_intf/output/lacp/periodic_transmission_machine_state (enumeration)
YANG Description: The state of the 'Periodic Transmission
machine' | f336774:c0:m36 |
def _set_periodic_transmission_machine_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:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:3>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:5>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:6>}, 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.__periodic_transmission_machine_state = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for periodic_transmission_machine_state, mapped from YANG variable /brocade_lag_rpc/get_portchannel_info_by_intf/output/lacp/periodic_transmission_machine_state (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_periodic_transmission_machine_state is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_periodic_transmission_machine_state() directly.
YANG Description: The state of the 'Periodic Transmission
machine' | f336774:c0:m37 |
def _get_mux_machine_state(self): | return self.__mux_machine_state<EOL> | Getter method for mux_machine_state, mapped from YANG variable /brocade_lag_rpc/get_portchannel_info_by_intf/output/lacp/mux_machine_state (enumeration)
YANG Description: The state of the 'Mux machine' | f336774:c0:m39 |
def _set_mux_machine_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:5>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:8>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:12>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:9>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:7>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:11>}, 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:3>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:10>}, 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.__mux_machine_state = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mux_machine_state, mapped from YANG variable /brocade_lag_rpc/get_portchannel_info_by_intf/output/lacp/mux_machine_state (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_mux_machine_state is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mux_machine_state() directly.
YANG Description: The state of the 'Mux machine' | f336774:c0:m40 |
def _get_admin_state(self): | return self.__admin_state<EOL> | Getter method for admin_state, mapped from YANG variable /brocade_lag_rpc/get_portchannel_info_by_intf/output/lacp/admin_state (lacp-state)
YANG Description: The Admin state | f336774:c0:m42 |
def _set_admin_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:2>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:5>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:3>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:6>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:0>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:7>}},), 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_state = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for admin_state, mapped from YANG variable /brocade_lag_rpc/get_portchannel_info_by_intf/output/lacp/admin_state (lacp-state)
If this variable is read-only (config: false) in the
source YANG file, then _set_admin_state is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_admin_state() directly.
YANG Description: The Admin state | f336774:c0:m43 |
def _get_oper_state(self): | return self.__oper_state<EOL> | Getter method for oper_state, mapped from YANG variable /brocade_lag_rpc/get_portchannel_info_by_intf/output/lacp/oper_state (lacp-state)
YANG Description: The Operational state | f336774:c0:m45 |
def _set_oper_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:2>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:5>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:3>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:6>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:0>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:7>}},), 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_state = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for oper_state, mapped from YANG variable /brocade_lag_rpc/get_portchannel_info_by_intf/output/lacp/oper_state (lacp-state)
If this variable is read-only (config: false) in the
source YANG file, then _set_oper_state is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_oper_state() directly.
YANG Description: The Operational state | f336774:c0:m46 |
def _get_partner_oper_state(self): | return self.__partner_oper_state<EOL> | Getter method for partner_oper_state, mapped from YANG variable /brocade_lag_rpc/get_portchannel_info_by_intf/output/lacp/partner_oper_state (lacp-state)
YANG Description: The Partner Operational state | f336774:c0:m48 |
def _set_partner_oper_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:2>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:5>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:3>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:6>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:0>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:7>}},), 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.__partner_oper_state = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for partner_oper_state, mapped from YANG variable /brocade_lag_rpc/get_portchannel_info_by_intf/output/lacp/partner_oper_state (lacp-state)
If this variable is read-only (config: false) in the
source YANG file, then _set_partner_oper_state is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_partner_oper_state() directly.
YANG Description: The Partner Operational state | f336774:c0:m49 |
def _get_partner_oper_port(self): | return self.__partner_oper_port<EOL> | Getter method for partner_oper_port, mapped from YANG variable /brocade_lag_rpc/get_portchannel_info_by_intf/output/lacp/partner_oper_port (uint64)
YANG Description: The Partner Operational port | f336774:c0:m51 |
def _set_partner_oper_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=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.__partner_oper_port = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for partner_oper_port, mapped from YANG variable /brocade_lag_rpc/get_portchannel_info_by_intf/output/lacp/partner_oper_port (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_partner_oper_port is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_partner_oper_port() directly.
YANG Description: The Partner Operational port | f336774:c0:m52 |
def _get_actor_chip_number(self): | return self.__actor_chip_number<EOL> | Getter method for actor_chip_number, mapped from YANG variable /brocade_lag_rpc/get_portchannel_info_by_intf/output/lacp/actor_chip_number (uint32)
YANG Description: The actor chip number | f336774:c0:m54 |
def _set_actor_chip_number(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.__actor_chip_number = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for actor_chip_number, mapped from YANG variable /brocade_lag_rpc/get_portchannel_info_by_intf/output/lacp/actor_chip_number (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_actor_chip_number is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_actor_chip_number() directly.
YANG Description: The actor chip number | f336774:c0:m55 |
def _get_actor_max_deskew(self): | return self.__actor_max_deskew<EOL> | Getter method for actor_max_deskew, mapped from YANG variable /brocade_lag_rpc/get_portchannel_info_by_intf/output/lacp/actor_max_deskew (uint32)
YANG Description: The actor maximum deskew | f336774:c0:m57 |
def _set_actor_max_deskew(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.__actor_max_deskew = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for actor_max_deskew, mapped from YANG variable /brocade_lag_rpc/get_portchannel_info_by_intf/output/lacp/actor_max_deskew (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_actor_max_deskew is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_actor_max_deskew() directly.
YANG Description: The actor maximum deskew | f336774:c0:m58 |
def _get_partner_chip_number(self): | return self.__partner_chip_number<EOL> | Getter method for partner_chip_number, mapped from YANG variable /brocade_lag_rpc/get_portchannel_info_by_intf/output/lacp/partner_chip_number (uint32)
YANG Description: The actor chip number | f336774:c0:m60 |
def _set_partner_chip_number(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.__partner_chip_number = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for partner_chip_number, mapped from YANG variable /brocade_lag_rpc/get_portchannel_info_by_intf/output/lacp/partner_chip_number (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_partner_chip_number is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_partner_chip_number() directly.
YANG Description: The actor chip number | f336774:c0:m61 |
def _get_partner_max_deskew(self): | return self.__partner_max_deskew<EOL> | Getter method for partner_max_deskew, mapped from YANG variable /brocade_lag_rpc/get_portchannel_info_by_intf/output/lacp/partner_max_deskew (uint32)
YANG Description: The partner maximum deskew | f336774:c0:m63 |
def _set_partner_max_deskew(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.__partner_max_deskew = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for partner_max_deskew, mapped from YANG variable /brocade_lag_rpc/get_portchannel_info_by_intf/output/lacp/partner_max_deskew (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_partner_max_deskew is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_partner_max_deskew() directly.
YANG Description: The partner maximum deskew | f336774:c0:m64 |
def _get_actor_brcd_state(self): | return self.__actor_brcd_state<EOL> | Getter method for actor_brcd_state, mapped from YANG variable /brocade_lag_rpc/get_portchannel_info_by_intf/output/lacp/actor_brcd_state (brcd-trunk-states)
YANG Description: Actor brcd trunk state | f336774:c0:m66 |
def _set_actor_brcd_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:3>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:4>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:0>}, 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.__actor_brcd_state = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for actor_brcd_state, mapped from YANG variable /brocade_lag_rpc/get_portchannel_info_by_intf/output/lacp/actor_brcd_state (brcd-trunk-states)
If this variable is read-only (config: false) in the
source YANG file, then _set_actor_brcd_state is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_actor_brcd_state() directly.
YANG Description: Actor brcd trunk state | f336774:c0:m67 |
def _get_partner_brcd_state(self): | return self.__partner_brcd_state<EOL> | Getter method for partner_brcd_state, mapped from YANG variable /brocade_lag_rpc/get_portchannel_info_by_intf/output/lacp/partner_brcd_state (brcd-trunk-states)
YANG Description: partner brcd trunk state | f336774:c0:m69 |
def _set_partner_brcd_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:3>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:4>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:0>}, 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.__partner_brcd_state = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for partner_brcd_state, mapped from YANG variable /brocade_lag_rpc/get_portchannel_info_by_intf/output/lacp/partner_brcd_state (brcd-trunk-states)
If this variable is read-only (config: false) in the
source YANG file, then _set_partner_brcd_state is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_partner_brcd_state() directly.
YANG Description: partner brcd trunk state | f336774:c0:m70 |
def _get_aggregator_id(self): | return self.__aggregator_id<EOL> | Getter method for aggregator_id, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/input/aggregator_id (interface:portchannel-type)
YANG Description: Aggregator-id for which configuration paramaters
will be shown. | f336775:c0:m3 |
def _set_aggregator_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=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, 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.__aggregator_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for aggregator_id, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/input/aggregator_id (interface:portchannel-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_aggregator_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_aggregator_id() directly.
YANG Description: Aggregator-id for which configuration paramaters
will be shown. | f336775:c0:m4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.