signature
stringlengths 8
3.44k
| body
stringlengths 0
1.41M
| docstring
stringlengths 1
122k
| id
stringlengths 5
17
|
|---|---|---|---|
def _get_last_aggregator_id(self): | return self.__last_aggregator_id<EOL> | Getter method for last_aggregator_id, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/input/last_aggregator_id (interface:portchannel-type)
YANG Description: Aggregator-id value should be given only when previous
response indicates that more records exists. This value
will be the Id of last aggregator received in previous
response. | f336775:c0:m6 |
def _set_last_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.__last_aggregator_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for last_aggregator_id, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/input/last_aggregator_id (interface:portchannel-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_last_aggregator_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_last_aggregator_id() directly.
YANG Description: Aggregator-id value should be given only when previous
response indicates that more records exists. This value
will be the Id of last aggregator received in previous
response. | f336775:c0:m7 |
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/output/lacp/aggregator_id (interface:portchannel-type)
YANG Description: Agreegator id | f336776: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, 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/output/lacp/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: Agreegator id | f336776:c0:m4 |
def _get_aggregator_type(self): | return self.__aggregator_type<EOL> | Getter method for aggregator_type, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/output/lacp/aggregator_type (enumeration) | f336776:c0:m6 |
def _set_aggregator_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:4>}, 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: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.__aggregator_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for aggregator_type, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/output/lacp/aggregator_type (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_aggregator_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_aggregator_type() directly. | f336776:c0:m7 |
def _get_isvlag(self): | return self.__isvlag<EOL> | Getter method for isvlag, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/output/lacp/isvlag (boolean)
YANG Description: Specifies if Agreegator is vlag. | f336776:c0:m9 |
def _set_isvlag(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.__isvlag = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for isvlag, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/output/lacp/isvlag (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_isvlag is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_isvlag() directly.
YANG Description: Specifies if Agreegator is vlag. | f336776:c0:m10 |
def _get_aggregator_mode(self): | return self.__aggregator_mode<EOL> | Getter method for aggregator_mode, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/output/lacp/aggregator_mode (enumeration) | f336776:c0:m12 |
def _set_aggregator_mode(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}, u'<STR_LIT:none>': {'<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.__aggregator_mode = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for aggregator_mode, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/output/lacp/aggregator_mode (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_aggregator_mode is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_aggregator_mode() directly. | f336776:c0:m13 |
def _get_admin_key(self): | return self.__admin_key<EOL> | Getter method for admin_key, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/output/lacp/admin_key (lacp-key)
YANG Description: The Admin key | f336776:c0:m15 |
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_port_channel_detail/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 | f336776:c0:m16 |
def _get_oper_key(self): | return self.__oper_key<EOL> | Getter method for oper_key, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/output/lacp/oper_key (lacp-key)
YANG Description: The Opertional key | f336776:c0:m18 |
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_port_channel_detail/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 | f336776:c0:m19 |
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_port_channel_detail/output/lacp/actor_system_id (yang:mac-address)
YANG Description: The Actor system id | f336776:c0:m21 |
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_port_channel_detail/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 | f336776:c0:m22 |
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_port_channel_detail/output/lacp/partner_system_id (yang:mac-address)
YANG Description: The Partner system id | f336776:c0:m24 |
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_port_channel_detail/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 | f336776:c0:m25 |
def _get_system_priority(self): | return self.__system_priority<EOL> | Getter method for system_priority, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/output/lacp/system_priority (uint32)
YANG Description: The System Priority | f336776:c0:m27 |
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_port_channel_detail/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 | f336776:c0:m28 |
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_port_channel_detail/output/lacp/partner_oper_priority (uint32)
YANG Description: The partner operational priority | f336776:c0:m30 |
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_port_channel_detail/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 | f336776:c0:m31 |
def _get_rx_link_count(self): | return self.__rx_link_count<EOL> | Getter method for rx_link_count, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/output/lacp/rx_link_count (uint64)
YANG Description: The RX link counter | f336776:c0:m33 |
def _set_rx_link_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_link_count = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rx_link_count, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/output/lacp/rx_link_count (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_rx_link_count is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rx_link_count() directly.
YANG Description: The RX link counter | f336776:c0:m34 |
def _get_tx_link_count(self): | return self.__tx_link_count<EOL> | Getter method for tx_link_count, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/output/lacp/tx_link_count (uint64)
YANG Description: The RX link counter | f336776:c0:m36 |
def _set_tx_link_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_link_count = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for tx_link_count, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/output/lacp/tx_link_count (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_tx_link_count is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tx_link_count() directly.
YANG Description: The RX link counter | f336776:c0:m37 |
def _get_individual_agg(self): | return self.__individual_agg<EOL> | Getter method for individual_agg, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/output/lacp/individual_agg (uint32)
YANG Description: Individual aggregator | f336776:c0:m39 |
def _set_individual_agg(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.__individual_agg = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for individual_agg, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/output/lacp/individual_agg (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_individual_agg is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_individual_agg() directly.
YANG Description: Individual aggregator | f336776:c0:m40 |
def _get_ready_agg(self): | return self.__ready_agg<EOL> | Getter method for ready_agg, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/output/lacp/ready_agg (uint32)
YANG Description: Individual aggregator | f336776:c0:m42 |
def _set_ready_agg(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.__ready_agg = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ready_agg, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/output/lacp/ready_agg (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_ready_agg is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ready_agg() directly.
YANG Description: Individual aggregator | f336776:c0:m43 |
def _get_partner_oper_key(self): | return self.__partner_oper_key<EOL> | Getter method for partner_oper_key, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/output/lacp/partner_oper_key (lacp-key)
YANG Description: The Partner Opertional key | f336776:c0:m45 |
def _set_partner_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.__partner_oper_key = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for partner_oper_key, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/output/lacp/partner_oper_key (lacp-key)
If this variable is read-only (config: false) in the
source YANG file, then _set_partner_oper_key is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_partner_oper_key() directly.
YANG Description: The Partner Opertional key | f336776:c0:m46 |
def _get_aggr_member(self): | return self.__aggr_member<EOL> | Getter method for aggr_member, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/output/lacp/aggr_member (list)
YANG Description: Describes the aggregator member
details. | f336776:c0:m48 |
def _set_aggr_member(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGListType(False,aggr_member.aggr_member, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT:False>', extensions=None), is_container='<STR_LIT:list>', yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, extensions=None, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:list>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__aggr_member = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for aggr_member, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/output/lacp/aggr_member (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_aggr_member is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_aggr_member() directly.
YANG Description: Describes the aggregator member
details. | f336776:c0:m49 |
def _get_interface_type(self): | return self.__interface_type<EOL> | Getter method for interface_type, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/output/lacp/aggr_member/interface_type (enumeration)
YANG Description: The type of the interface. An 'unknown' type
represents error scenario and should not be used. | f336777: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_port_channel_detail/output/lacp/aggr_member/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. | f336777: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_port_channel_detail/output/lacp/aggr_member/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. | f336777: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_port_channel_detail/output/lacp/aggr_member/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. | f336777: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_port_channel_detail/output/lacp/aggr_member/actor_port (uint64)
YANG Description: The actor port number.
This is valid only in active mode only. | f336777: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_port_channel_detail/output/lacp/aggr_member/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.
This is valid only in active mode only. | f336777:c0:m10 |
def _get_sync(self): | return self.__sync<EOL> | Getter method for sync, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/output/lacp/aggr_member/sync (uint64)
YANG Description: sync-info.
This is valid in active mode only. | f336777:c0:m12 |
def _set_sync(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.__sync = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for sync, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/output/lacp/aggr_member/sync (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_sync is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_sync() directly.
YANG Description: sync-info.
This is valid in active mode only. | f336777:c0:m13 |
def _get_policy_name(self): | return self.__policy_name<EOL> | Getter method for policy_name, mapped from YANG variable /overlay_policy_map_get_next_cookie_state/policy_name (string)
YANG Description: Overlay Policy Map name | f336778:c0:m3 |
def _set_policy_name(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__policy_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for policy_name, mapped from YANG variable /overlay_policy_map_get_next_cookie_state/policy_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_policy_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_policy_name() directly.
YANG Description: Overlay Policy Map name | f336778:c0:m4 |
def _get_seq_id(self): | return self.__seq_id<EOL> | Getter method for seq_id, mapped from YANG variable /overlay_policy_map_get_next_cookie_state/seq_id (uint32)
YANG Description: Sequence Id | f336778:c0:m6 |
def _set_seq_id(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=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=True, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__seq_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for seq_id, mapped from YANG variable /overlay_policy_map_get_next_cookie_state/seq_id (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_seq_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_seq_id() directly.
YANG Description: Sequence Id | f336778:c0:m7 |
def _get_policy_name(self): | return self.__policy_name<EOL> | Getter method for policy_name, mapped from YANG variable /overlay_policy_map_state/policy_name (string)
YANG Description: Overlay Policy Map name | f336779:c0:m3 |
def _set_policy_name(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__policy_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for policy_name, mapped from YANG variable /overlay_policy_map_state/policy_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_policy_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_policy_name() directly.
YANG Description: Overlay Policy Map name | f336779:c0:m4 |
def _get_active_on(self): | return self.__active_on<EOL> | Getter method for active_on, mapped from YANG variable /overlay_policy_map_state/active_on (container)
YANG Description: Active Interfaces | f336779:c0:m6 |
def _set_active_on(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=active_on.active_on, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__active_on = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for active_on, mapped from YANG variable /overlay_policy_map_state/active_on (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_active_on is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_active_on() directly.
YANG Description: Active Interfaces | f336779:c0:m7 |
def _get_overlay_class(self): | return self.__overlay_class<EOL> | Getter method for overlay_class, mapped from YANG variable /overlay_policy_map_state/overlay_class (list)
YANG Description: Overlay Class | f336779:c0:m9 |
def _set_overlay_class(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGListType("<STR_LIT>",overlay_class.overlay_class, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT>', extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}), is_container='<STR_LIT:list>', yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:list>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__overlay_class = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for overlay_class, mapped from YANG variable /overlay_policy_map_state/overlay_class (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_overlay_class is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_overlay_class() directly.
YANG Description: Overlay Class | f336779:c0:m10 |
def _get_interface_type(self): | return self.__interface_type<EOL> | Getter method for interface_type, mapped from YANG variable /overlay_policy_map_state/active_on/interface_type (string)
YANG Description: Interface Type | f336780: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=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__interface_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for interface_type, mapped from YANG variable /overlay_policy_map_state/active_on/interface_type (string)
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: Interface Type | f336780:c0:m4 |
def _get_interface_name(self): | return self.__interface_name<EOL> | Getter method for interface_name, mapped from YANG variable /overlay_policy_map_state/active_on/interface_name (string)
YANG Description: Interface Name | f336780: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=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__interface_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for interface_name, mapped from YANG variable /overlay_policy_map_state/active_on/interface_name (string)
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: Interface Name | f336780:c0:m7 |
def _get_seq_id(self): | return self.__seq_id<EOL> | Getter method for seq_id, mapped from YANG variable /overlay_policy_map_state/overlay_class/seq_id (uint32)
YANG Description: Sequence Id | f336781:c0:m3 |
def _set_seq_id(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=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=True, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__seq_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for seq_id, mapped from YANG variable /overlay_policy_map_state/overlay_class/seq_id (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_seq_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_seq_id() directly.
YANG Description: Sequence Id | f336781:c0:m4 |
def _get_overlay_class_name(self): | return self.__overlay_class_name<EOL> | Getter method for overlay_class_name, mapped from YANG variable /overlay_policy_map_state/overlay_class/overlay_class_name (string)
YANG Description: Overlay Class name | f336781:c0:m6 |
def _set_overlay_class_name(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__overlay_class_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for overlay_class_name, mapped from YANG variable /overlay_policy_map_state/overlay_class/overlay_class_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_overlay_class_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_overlay_class_name() directly.
YANG Description: Overlay Class name | f336781:c0:m7 |
def _get_mac_acl_name(self): | return self.__mac_acl_name<EOL> | Getter method for mac_acl_name, mapped from YANG variable /overlay_policy_map_state/overlay_class/mac_acl_name (string)
YANG Description: Mac Access List name | f336781:c0:m9 |
def _set_mac_acl_name(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__mac_acl_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mac_acl_name, mapped from YANG variable /overlay_policy_map_state/overlay_class/mac_acl_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_mac_acl_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mac_acl_name() directly.
YANG Description: Mac Access List name | f336781:c0:m10 |
def _get_ip_acl_name(self): | return self.__ip_acl_name<EOL> | Getter method for ip_acl_name, mapped from YANG variable /overlay_policy_map_state/overlay_class/ip_acl_name (string)
YANG Description: IP Access List name | f336781:c0:m12 |
def _set_ip_acl_name(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__ip_acl_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ip_acl_name, mapped from YANG variable /overlay_policy_map_state/overlay_class/ip_acl_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_ip_acl_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ip_acl_name() directly.
YANG Description: IP Access List name | f336781:c0:m13 |
def _get_ipv6_acl_name(self): | return self.__ipv6_acl_name<EOL> | Getter method for ipv6_acl_name, mapped from YANG variable /overlay_policy_map_state/overlay_class/ipv6_acl_name (string)
YANG Description: IPv6 Access List name | f336781:c0:m15 |
def _set_ipv6_acl_name(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__ipv6_acl_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ipv6_acl_name, mapped from YANG variable /overlay_policy_map_state/overlay_class/ipv6_acl_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_ipv6_acl_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ipv6_acl_name() directly.
YANG Description: IPv6 Access List name | f336781:c0:m16 |
def _get_service_policy_name(self): | return self.__service_policy_name<EOL> | Getter method for service_policy_name, mapped from YANG variable /overlay_policy_map_state/overlay_class/service_policy_name (string)
YANG Description: Service Policy name | f336781:c0:m18 |
def _set_service_policy_name(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__service_policy_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for service_policy_name, mapped from YANG variable /overlay_policy_map_state/overlay_class/service_policy_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_service_policy_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_service_policy_name() directly.
YANG Description: Service Policy name | f336781:c0:m19 |
def _get_qos_mpls(self): | return self.__qos_mpls<EOL> | Getter method for qos_mpls, mapped from YANG variable /exp_dscp_state/qos_mpls (list) | f336782:c0:m3 |
def _set_qos_mpls(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGListType("<STR_LIT>",qos_mpls.qos_mpls, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT>', extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>'}}), is_container='<STR_LIT:list>', yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:list>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__qos_mpls = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for qos_mpls, mapped from YANG variable /exp_dscp_state/qos_mpls (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_qos_mpls is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_qos_mpls() directly. | f336782:c0:m4 |
def _get_map_type(self): | return self.__map_type<EOL> | Getter method for map_type, mapped from YANG variable /exp_dscp_state/qos_mpls/map_type (string)
YANG Description: map_type | f336783:c0:m3 |
def _set_map_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=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__map_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for map_type, mapped from YANG variable /exp_dscp_state/qos_mpls/map_type (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_map_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_map_type() directly.
YANG Description: map_type | f336783:c0:m4 |
def _get_map_name(self): | return self.__map_name<EOL> | Getter method for map_name, mapped from YANG variable /exp_dscp_state/qos_mpls/map_name (string)
YANG Description: map_name | f336783:c0:m6 |
def _set_map_name(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__map_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for map_name, mapped from YANG variable /exp_dscp_state/qos_mpls/map_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_map_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_map_name() directly.
YANG Description: map_name | f336783:c0:m7 |
def _get_enabled_slots(self): | return self.__enabled_slots<EOL> | Getter method for enabled_slots, mapped from YANG variable /exp_dscp_state/qos_mpls/enabled_slots (string)
YANG Description: enabled_slots | f336783:c0:m9 |
def _set_enabled_slots(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__enabled_slots = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for enabled_slots, mapped from YANG variable /exp_dscp_state/qos_mpls/enabled_slots (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_enabled_slots is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_enabled_slots() directly.
YANG Description: enabled_slots | f336783:c0:m10 |
def _get_traffic_class(self): | return self.__traffic_class<EOL> | Getter method for traffic_class, mapped from YANG variable /exp_dscp_state/qos_mpls/traffic_class (uint32)
YANG Description: traffic-class | f336783:c0:m12 |
def _set_traffic_class(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>)), is_leaf=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__traffic_class = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for traffic_class, mapped from YANG variable /exp_dscp_state/qos_mpls/traffic_class (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_traffic_class is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_traffic_class() directly.
YANG Description: traffic-class | f336783:c0:m13 |
def _get_drop_preced(self): | return self.__drop_preced<EOL> | Getter method for drop_preced, mapped from YANG variable /exp_dscp_state/qos_mpls/drop_preced (uint32)
YANG Description: drop-preced | f336783:c0:m15 |
def _set_drop_preced(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>)), is_leaf=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__drop_preced = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for drop_preced, mapped from YANG variable /exp_dscp_state/qos_mpls/drop_preced (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_drop_preced is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_drop_preced() directly.
YANG Description: drop-preced | f336783:c0:m16 |
def _get_exp(self): | return self.__exp<EOL> | Getter method for exp, mapped from YANG variable /exp_dscp_state/qos_mpls/exp (uint32)
YANG Description: exp-val | f336783:c0:m18 |
def _set_exp(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>)), is_leaf=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__exp = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for exp, mapped from YANG variable /exp_dscp_state/qos_mpls/exp (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_exp is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_exp() directly.
YANG Description: exp-val | f336783:c0:m19 |
def _get_dscp(self): | return self.__dscp<EOL> | Getter method for dscp, mapped from YANG variable /exp_dscp_state/qos_mpls/dscp (uint32)
YANG Description: dscp-val | f336783:c0:m21 |
def _set_dscp(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>)), is_leaf=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__dscp = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for dscp, mapped from YANG variable /exp_dscp_state/qos_mpls/dscp (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_dscp is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_dscp() directly.
YANG Description: dscp-val | f336783:c0:m22 |
def _get_exptrafficvalues(self): | return self.__exptrafficvalues<EOL> | Getter method for exptrafficvalues, mapped from YANG variable /exp_dscp_state/qos_mpls/exptrafficvalues (uint32)
YANG Description: exptrafficvalues | f336783:c0:m24 |
def _set_exptrafficvalues(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>)), is_leaf=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__exptrafficvalues = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for exptrafficvalues, mapped from YANG variable /exp_dscp_state/qos_mpls/exptrafficvalues (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_exptrafficvalues is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_exptrafficvalues() directly.
YANG Description: exptrafficvalues | f336783:c0:m25 |
def _get_cluster_id(self): | return self.__cluster_id<EOL> | Getter method for cluster_id, mapped from YANG variable /show_client_id_df_info_state/cluster_id (uint32)
YANG Description: Cluster ID | f336784:c0:m3 |
def _set_cluster_id(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=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=True, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__cluster_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for cluster_id, mapped from YANG variable /show_client_id_df_info_state/cluster_id (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_cluster_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_cluster_id() directly.
YANG Description: Cluster ID | f336784:c0:m4 |
def _get_client_id(self): | return self.__client_id<EOL> | Getter method for client_id, mapped from YANG variable /show_client_id_df_info_state/client_id (uint32)
YANG Description: Client Id | f336784:c0:m6 |
def _set_client_id(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=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=True, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__client_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for client_id, mapped from YANG variable /show_client_id_df_info_state/client_id (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_client_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_client_id() directly.
YANG Description: Client Id | f336784:c0:m7 |
def _get_client_state(self): | return self.__client_state<EOL> | Getter method for client_state, mapped from YANG variable /show_client_id_df_info_state/client_state (boolean)
YANG Description: Client state | f336784:c0:m9 |
def _set_client_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=YANGBool, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__client_state = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for client_state, mapped from YANG variable /show_client_id_df_info_state/client_state (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_client_state is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_client_state() directly.
YANG Description: Client state | f336784:c0:m10 |
def _get_is_all_vlan_elected(self): | return self.__is_all_vlan_elected<EOL> | Getter method for is_all_vlan_elected, mapped from YANG variable /show_client_id_df_info_state/is_all_vlan_elected (uint32)
YANG Description: All VLANs are elected as DF | f336784:c0:m12 |
def _set_is_all_vlan_elected(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=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__is_all_vlan_elected = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for is_all_vlan_elected, mapped from YANG variable /show_client_id_df_info_state/is_all_vlan_elected (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_is_all_vlan_elected is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_is_all_vlan_elected() directly.
YANG Description: All VLANs are elected as DF | f336784:c0:m13 |
def _get_is_df_election_pending(self): | return self.__is_df_election_pending<EOL> | Getter method for is_df_election_pending, mapped from YANG variable /show_client_id_df_info_state/is_df_election_pending (uint32)
YANG Description: DF election pending | f336784:c0:m15 |
def _set_is_df_election_pending(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=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__is_df_election_pending = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for is_df_election_pending, mapped from YANG variable /show_client_id_df_info_state/is_df_election_pending (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_is_df_election_pending is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_is_df_election_pending() directly.
YANG Description: DF election pending | f336784:c0:m16 |
def _get_num_df_vlans(self): | return self.__num_df_vlans<EOL> | Getter method for num_df_vlans, mapped from YANG variable /show_client_id_df_info_state/num_df_vlans (uint32)
YANG Description: No. of DF Vlans configured | f336784:c0:m18 |
def _set_num_df_vlans(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=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__num_df_vlans = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for num_df_vlans, mapped from YANG variable /show_client_id_df_info_state/num_df_vlans (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_num_df_vlans is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_num_df_vlans() directly.
YANG Description: No. of DF Vlans configured | f336784:c0:m19 |
def _get_num_df_bds(self): | return self.__num_df_bds<EOL> | Getter method for num_df_bds, mapped from YANG variable /show_client_id_df_info_state/num_df_bds (uint32)
YANG Description: No. of DF BDs configured | f336784:c0:m21 |
def _set_num_df_bds(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=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__num_df_bds = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for num_df_bds, mapped from YANG variable /show_client_id_df_info_state/num_df_bds (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_num_df_bds is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_num_df_bds() directly.
YANG Description: No. of DF BDs configured | f336784:c0:m22 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.