signature stringlengths 8 3.44k | body stringlengths 0 1.41M | docstring stringlengths 1 122k | id stringlengths 5 17 |
|---|---|---|---|
def _get_underflow_limit(self): | return self.__underflow_limit<EOL> | Getter method for underflow_limit, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/lsp/lsp_auto_bandwidth/underflow_limit (uint32) | f336485:c0:m27 |
def _set_underflow_limit(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), default=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>)(<NUM_LIT:0>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__underflow_limit = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for underflow_limit, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/lsp/lsp_auto_bandwidth/underflow_limit (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_underflow_limit is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_underflow_limit() directly. | f336485:c0:m28 |
def _get_lsp_name(self): | return self.__lsp_name<EOL> | Getter method for lsp_name, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/lsp/lsp_name (string) | f336486:c0:m3 |
def _set_lsp_name(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>'}}, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=True)<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.__lsp_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for lsp_name, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/lsp/lsp_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_lsp_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lsp_name() directly. | f336486:c0:m4 |
def _get_lsp_dest_address(self): | return self.__lsp_dest_address<EOL> | Getter method for lsp_dest_address, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/lsp/lsp_dest_address (inet:ipv4-address) | f336486:c0:m6 |
def _set_lsp_dest_address(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>'}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT:to>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT:to>'}}, 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.__lsp_dest_address = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for lsp_dest_address, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/lsp/lsp_dest_address (inet:ipv4-address)
If this variable is read-only (config: false) in the
source YANG file, then _set_lsp_dest_address is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lsp_dest_address() directly. | f336486:c0:m7 |
def _get_lsp_cspf(self): | return self.__lsp_cspf<EOL> | Getter method for lsp_cspf, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/lsp/lsp_cspf (enable-disable) | f336486:c0:m9 |
def _set_lsp_cspf(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:0>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__lsp_cspf = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for lsp_cspf, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/lsp/lsp_cspf (enable-disable)
If this variable is read-only (config: false) in the
source YANG file, then _set_lsp_cspf is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lsp_cspf() directly. | f336486:c0:m10 |
def _get_lsp_ipmtu(self): | return self.__lsp_ipmtu<EOL> | Getter method for lsp_ipmtu, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/lsp/lsp_ipmtu (uint32) | f336486:c0:m12 |
def _set_lsp_ipmtu(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__lsp_ipmtu = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for lsp_ipmtu, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/lsp/lsp_ipmtu (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_lsp_ipmtu is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lsp_ipmtu() directly. | f336486:c0:m13 |
def _get_lsp_metric(self): | return self.__lsp_metric<EOL> | Getter method for lsp_metric, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/lsp/lsp_metric (uint32) | f336486:c0:m15 |
def _set_lsp_metric(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__lsp_metric = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for lsp_metric, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/lsp/lsp_metric (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_lsp_metric is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lsp_metric() directly. | f336486:c0:m16 |
def _get_lsp_revert_timer(self): | return self.__lsp_revert_timer<EOL> | Getter method for lsp_revert_timer, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/lsp/lsp_revert_timer (uint32) | f336486:c0:m18 |
def _set_lsp_revert_timer(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__lsp_revert_timer = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for lsp_revert_timer, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/lsp/lsp_revert_timer (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_lsp_revert_timer is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lsp_revert_timer() directly. | f336486:c0:m19 |
def _get_lsp_tie_breaking(self): | return self.__lsp_tie_breaking<EOL> | Getter method for lsp_tie_breaking, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/lsp/lsp_tie_breaking (tie-breaking) | f336486:c0:m21 |
def _set_lsp_tie_breaking(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:0>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}},), default=unicode("<STR_LIT>"), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__lsp_tie_breaking = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for lsp_tie_breaking, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/lsp/lsp_tie_breaking (tie-breaking)
If this variable is read-only (config: false) in the
source YANG file, then _set_lsp_tie_breaking is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lsp_tie_breaking() directly. | f336486:c0:m22 |
def _get_lsp_src_address(self): | return self.__lsp_src_address<EOL> | Getter method for lsp_src_address, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/lsp/lsp_src_address (inet:ipv4-address) | f336486:c0:m24 |
def _set_lsp_src_address(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>'}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__lsp_src_address = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for lsp_src_address, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/lsp/lsp_src_address (inet:ipv4-address)
If this variable is read-only (config: false) in the
source YANG file, then _set_lsp_src_address is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lsp_src_address() directly. | f336486:c0:m25 |
def _get_lsp_primary_path(self): | return self.__lsp_primary_path<EOL> | Getter method for lsp_primary_path, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/lsp/lsp_primary_path (string) | f336486:c0:m27 |
def _set_lsp_primary_path(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=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=True)<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.__lsp_primary_path = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for lsp_primary_path, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/lsp/lsp_primary_path (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_lsp_primary_path is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lsp_primary_path() directly. | f336486:c0:m28 |
def _get_lsp_adaptive(self): | return self.__lsp_adaptive<EOL> | Getter method for lsp_adaptive, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/lsp/lsp_adaptive (empty) | f336486:c0:m30 |
def _set_lsp_adaptive(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__lsp_adaptive = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for lsp_adaptive, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/lsp/lsp_adaptive (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_lsp_adaptive is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lsp_adaptive() directly. | f336486:c0:m31 |
def _get_lsp_reoptimize_timer(self): | return self.__lsp_reoptimize_timer<EOL> | Getter method for lsp_reoptimize_timer, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/lsp/lsp_reoptimize_timer (uint32) | f336486:c0:m33 |
def _set_lsp_reoptimize_timer(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__lsp_reoptimize_timer = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for lsp_reoptimize_timer, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/lsp/lsp_reoptimize_timer (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_lsp_reoptimize_timer is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lsp_reoptimize_timer() directly. | f336486:c0:m34 |
def _get_lsp_commit(self): | return self.__lsp_commit<EOL> | Getter method for lsp_commit, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/lsp/lsp_commit (empty) | f336486:c0:m36 |
def _set_lsp_commit(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__lsp_commit = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for lsp_commit, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/lsp/lsp_commit (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_lsp_commit is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lsp_commit() directly. | f336486:c0:m37 |
def _get_lsp_record(self): | return self.__lsp_record<EOL> | Getter method for lsp_record, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/lsp/lsp_record (enable-disable) | f336486:c0:m39 |
def _set_lsp_record(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:0>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__lsp_record = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for lsp_record, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/lsp/lsp_record (enable-disable)
If this variable is read-only (config: false) in the
source YANG file, then _set_lsp_record is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lsp_record() directly. | f336486:c0:m40 |
def _get_lsp_cos(self): | return self.__lsp_cos<EOL> | Getter method for lsp_cos, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/lsp/lsp_cos (uint32) | f336486:c0:m42 |
def _set_lsp_cos(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__lsp_cos = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for lsp_cos, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/lsp/lsp_cos (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_lsp_cos is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lsp_cos() directly. | f336486:c0:m43 |
def _get_lsp_hop_limit(self): | return self.__lsp_hop_limit<EOL> | Getter method for lsp_hop_limit, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/lsp/lsp_hop_limit (uint16) | f336486:c0:m45 |
def _set_lsp_hop_limit(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']},int_size=<NUM_LIT:16>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__lsp_hop_limit = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for lsp_hop_limit, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/lsp/lsp_hop_limit (uint16)
If this variable is read-only (config: false) in the
source YANG file, then _set_lsp_hop_limit is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lsp_hop_limit() directly. | f336486:c0:m46 |
def _get_lsp_cspf_computation_mode(self): | return self.__lsp_cspf_computation_mode<EOL> | Getter method for lsp_cspf_computation_mode, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/lsp/lsp_cspf_computation_mode (cspf-computation-mode) | f336486:c0:m48 |
def _set_lsp_cspf_computation_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:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__lsp_cspf_computation_mode = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for lsp_cspf_computation_mode, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/lsp/lsp_cspf_computation_mode (cspf-computation-mode)
If this variable is read-only (config: false) in the
source YANG file, then _set_lsp_cspf_computation_mode is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lsp_cspf_computation_mode() directly. | f336486:c0:m49 |
def _get_lsp_traffic_engineering(self): | return self.__lsp_traffic_engineering<EOL> | Getter method for lsp_traffic_engineering, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/lsp/lsp_traffic_engineering (container) | f336486:c0:m51 |
def _set_lsp_traffic_engineering(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=lsp_traffic_engineering.lsp_traffic_engineering, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__lsp_traffic_engineering = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for lsp_traffic_engineering, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/lsp/lsp_traffic_engineering (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_lsp_traffic_engineering is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lsp_traffic_engineering() directly. | f336486:c0:m52 |
def _get_priority(self): | return self.__priority<EOL> | Getter method for priority, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/lsp/priority (container) | f336486:c0:m54 |
def _set_priority(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=priority.priority, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__priority = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for priority, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/lsp/priority (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_priority is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_priority() directly. | f336486:c0:m55 |
def _get_lsp_exclude_any(self): | return self.__lsp_exclude_any<EOL> | Getter method for lsp_exclude_any, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/lsp/lsp_exclude_any (string) | f336486:c0:m57 |
def _set_lsp_exclude_any(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=unicode, restriction_dict={'<STR_LIT>': [u'<STR_LIT>']})), is_leaf=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=True)<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.__lsp_exclude_any = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for lsp_exclude_any, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/lsp/lsp_exclude_any (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_lsp_exclude_any is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lsp_exclude_any() directly. | f336486:c0:m58 |
def _get_lsp_include_any(self): | return self.__lsp_include_any<EOL> | Getter method for lsp_include_any, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/lsp/lsp_include_any (string) | f336486:c0:m60 |
def _set_lsp_include_any(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=unicode, restriction_dict={'<STR_LIT>': [u'<STR_LIT>']})), is_leaf=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=True)<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.__lsp_include_any = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for lsp_include_any, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/lsp/lsp_include_any (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_lsp_include_any is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lsp_include_any() directly. | f336486:c0:m61 |
def _get_lsp_include_all(self): | return self.__lsp_include_all<EOL> | Getter method for lsp_include_all, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/lsp/lsp_include_all (string) | f336486:c0:m63 |
def _set_lsp_include_all(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=TypedListType(allowed_type=RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': [u'<STR_LIT>']})), is_leaf=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=True)<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.__lsp_include_all = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for lsp_include_all, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/lsp/lsp_include_all (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_lsp_include_all is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lsp_include_all() directly. | f336486:c0:m64 |
def _get_lsp_soft_preemption(self): | return self.__lsp_soft_preemption<EOL> | Getter method for lsp_soft_preemption, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/lsp/lsp_soft_preemption (empty) | f336486:c0:m66 |
def _set_lsp_soft_preemption(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__lsp_soft_preemption = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for lsp_soft_preemption, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/lsp/lsp_soft_preemption (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_lsp_soft_preemption is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lsp_soft_preemption() directly. | f336486:c0:m67 |
def _get_lsp_auto_bandwidth(self): | return self.__lsp_auto_bandwidth<EOL> | Getter method for lsp_auto_bandwidth, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/lsp/lsp_auto_bandwidth (container) | f336486:c0:m69 |
def _set_lsp_auto_bandwidth(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=lsp_auto_bandwidth.lsp_auto_bandwidth, is_container='<STR_LIT>', presence=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__lsp_auto_bandwidth = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for lsp_auto_bandwidth, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/lsp/lsp_auto_bandwidth (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_lsp_auto_bandwidth is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lsp_auto_bandwidth() directly. | f336486:c0:m70 |
def _get_lsp_frr(self): | return self.__lsp_frr<EOL> | Getter method for lsp_frr, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/lsp/lsp_frr (container) | f336486:c0:m72 |
def _set_lsp_frr(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=lsp_frr.lsp_frr, is_container='<STR_LIT>', presence=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__lsp_frr = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for lsp_frr, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/lsp/lsp_frr (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_lsp_frr is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lsp_frr() directly. | f336486:c0:m73 |
def _get_secondary_path(self): | return self.__secondary_path<EOL> | Getter method for secondary_path, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/lsp/secondary_path (list) | f336486:c0:m75 |
def _set_secondary_path(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>",secondary_path.secondary_path, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT>', extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>'}}), is_container='<STR_LIT:list>', yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:list>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__secondary_path = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for secondary_path, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/lsp/secondary_path (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_secondary_path is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_secondary_path() directly. | f336486:c0:m76 |
def _get_lsp_select_path(self): | return self.__lsp_select_path<EOL> | Getter method for lsp_select_path, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/lsp/lsp_select_path (container) | f336486:c0:m78 |
def _set_lsp_select_path(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=lsp_select_path.lsp_select_path, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__lsp_select_path = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for lsp_select_path, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/lsp/lsp_select_path (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_lsp_select_path is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lsp_select_path() directly. | f336486:c0:m79 |
def _get_lsp_enable(self): | return self.__lsp_enable<EOL> | Getter method for lsp_enable, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/lsp/lsp_enable (empty) | f336486:c0:m81 |
def _set_lsp_enable(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__lsp_enable = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for lsp_enable, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/lsp/lsp_enable (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_lsp_enable is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lsp_enable() directly. | f336486:c0:m82 |
def _get_refresh_interval(self): | return self.__refresh_interval<EOL> | Getter method for refresh_interval, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/rsvp/refresh_interval (uint32) | f336487:c0:m3 |
def _set_refresh_interval(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), default=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>)(<NUM_LIT:30>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__refresh_interval = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for refresh_interval, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/rsvp/refresh_interval (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_refresh_interval is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_refresh_interval() directly. | f336487:c0:m4 |
def _get_refresh_multiple(self): | return self.__refresh_multiple<EOL> | Getter method for refresh_multiple, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/rsvp/refresh_multiple (uint32) | f336487:c0:m6 |
def _set_refresh_multiple(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), default=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>)(<NUM_LIT:3>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__refresh_multiple = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for refresh_multiple, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/rsvp/refresh_multiple (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_refresh_multiple is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_refresh_multiple() directly. | f336487:c0:m7 |
def _get_g_refresh_reduction(self): | return self.__g_refresh_reduction<EOL> | Getter method for g_refresh_reduction, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/rsvp/g_refresh_reduction (container) | f336487:c0:m9 |
def _set_g_refresh_reduction(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=g_refresh_reduction.g_refresh_reduction, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__g_refresh_reduction = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for g_refresh_reduction, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/rsvp/g_refresh_reduction (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_g_refresh_reduction is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_g_refresh_reduction() directly. | f336487:c0:m10 |
def _get_g_reliable_messaging(self): | return self.__g_reliable_messaging<EOL> | Getter method for g_reliable_messaging, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/rsvp/g_reliable_messaging (container) | f336487:c0:m12 |
def _set_g_reliable_messaging(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=g_reliable_messaging.g_reliable_messaging, is_container='<STR_LIT>', presence=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>'}}, 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.__g_reliable_messaging = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for g_reliable_messaging, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/rsvp/g_reliable_messaging (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_g_reliable_messaging is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_g_reliable_messaging() directly. | f336487:c0:m13 |
def _get_global_rsvp_hello(self): | return self.__global_rsvp_hello<EOL> | Getter method for global_rsvp_hello, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/rsvp/global_rsvp_hello (container) | f336487:c0:m15 |
def _set_global_rsvp_hello(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=global_rsvp_hello.global_rsvp_hello, is_container='<STR_LIT>', presence=True, yang_name="<STR_LIT>", rest_name="<STR_LIT:hello>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT:hello>'}}, 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.__global_rsvp_hello = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for global_rsvp_hello, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/rsvp/global_rsvp_hello (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_global_rsvp_hello is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_global_rsvp_hello() directly. | f336487:c0:m16 |
def _get_global_rsvp_hello_acknowledgements(self): | return self.__global_rsvp_hello_acknowledgements<EOL> | Getter method for global_rsvp_hello_acknowledgements, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/rsvp/global_rsvp_hello_acknowledgements (empty) | f336487:c0:m18 |
def _set_global_rsvp_hello_acknowledgements(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': 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.__global_rsvp_hello_acknowledgements = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for global_rsvp_hello_acknowledgements, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/rsvp/global_rsvp_hello_acknowledgements (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_global_rsvp_hello_acknowledgements is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_global_rsvp_hello_acknowledgements() directly. | f336487:c0:m19 |
def _get_global_rsvp_hello_unprioritize(self): | return self.__global_rsvp_hello_unprioritize<EOL> | Getter method for global_rsvp_hello_unprioritize, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/rsvp/global_rsvp_hello_unprioritize (empty) | f336487:c0:m21 |
def _set_global_rsvp_hello_unprioritize(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__global_rsvp_hello_unprioritize = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for global_rsvp_hello_unprioritize, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/rsvp/global_rsvp_hello_unprioritize (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_global_rsvp_hello_unprioritize is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_global_rsvp_hello_unprioritize() directly. | f336487:c0:m22 |
def _get_g_rsvp_backup_bw_guarantee(self): | return self.__g_rsvp_backup_bw_guarantee<EOL> | Getter method for g_rsvp_backup_bw_guarantee, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/rsvp/g_rsvp_backup_bw_guarantee (empty) | f336487:c0:m24 |
def _set_g_rsvp_backup_bw_guarantee(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__g_rsvp_backup_bw_guarantee = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for g_rsvp_backup_bw_guarantee, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/rsvp/g_rsvp_backup_bw_guarantee (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_g_rsvp_backup_bw_guarantee is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_g_rsvp_backup_bw_guarantee() directly. | f336487:c0:m25 |
def _get_dynamic_bypass_max_bypasses(self): | return self.__dynamic_bypass_max_bypasses<EOL> | Getter method for dynamic_bypass_max_bypasses, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/dynamic_bypass/mpls_dynamic_bypass_sub_cmds/dynamic_bypass_max_bypasses (uint32) | f336488:c0:m3 |
def _set_dynamic_bypass_max_bypasses(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), default=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>)(<NUM_LIT>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__dynamic_bypass_max_bypasses = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for dynamic_bypass_max_bypasses, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/dynamic_bypass/mpls_dynamic_bypass_sub_cmds/dynamic_bypass_max_bypasses (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_dynamic_bypass_max_bypasses is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_dynamic_bypass_max_bypasses() directly. | f336488:c0:m4 |
def _get_dynamic_bypass_max_bypasses_per_mp(self): | return self.__dynamic_bypass_max_bypasses_per_mp<EOL> | Getter method for dynamic_bypass_max_bypasses_per_mp, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/dynamic_bypass/mpls_dynamic_bypass_sub_cmds/dynamic_bypass_max_bypasses_per_mp (uint32) | f336488:c0:m6 |
def _set_dynamic_bypass_max_bypasses_per_mp(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), default=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>)(<NUM_LIT>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__dynamic_bypass_max_bypasses_per_mp = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for dynamic_bypass_max_bypasses_per_mp, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/dynamic_bypass/mpls_dynamic_bypass_sub_cmds/dynamic_bypass_max_bypasses_per_mp (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_dynamic_bypass_max_bypasses_per_mp is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_dynamic_bypass_max_bypasses_per_mp() directly. | f336488:c0:m7 |
def _get_dynamic_bypass_enable_all_interfaces(self): | return self.__dynamic_bypass_enable_all_interfaces<EOL> | Getter method for dynamic_bypass_enable_all_interfaces, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/dynamic_bypass/mpls_dynamic_bypass_sub_cmds/dynamic_bypass_enable_all_interfaces (empty) | f336488:c0:m9 |
def _set_dynamic_bypass_enable_all_interfaces(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__dynamic_bypass_enable_all_interfaces = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for dynamic_bypass_enable_all_interfaces, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/dynamic_bypass/mpls_dynamic_bypass_sub_cmds/dynamic_bypass_enable_all_interfaces (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_dynamic_bypass_enable_all_interfaces is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_dynamic_bypass_enable_all_interfaces() directly. | f336488:c0:m10 |
def _get_dynamic_bypass_reoptimize_timer(self): | return self.__dynamic_bypass_reoptimize_timer<EOL> | Getter method for dynamic_bypass_reoptimize_timer, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/dynamic_bypass/mpls_dynamic_bypass_sub_cmds/dynamic_bypass_reoptimize_timer (uint32) | f336488:c0:m12 |
def _set_dynamic_bypass_reoptimize_timer(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__dynamic_bypass_reoptimize_timer = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for dynamic_bypass_reoptimize_timer, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/dynamic_bypass/mpls_dynamic_bypass_sub_cmds/dynamic_bypass_reoptimize_timer (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_dynamic_bypass_reoptimize_timer is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_dynamic_bypass_reoptimize_timer() directly. | f336488:c0:m13 |
def _get_dynamic_bypass_disable(self): | return self.__dynamic_bypass_disable<EOL> | Getter method for dynamic_bypass_disable, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/dynamic_bypass/mpls_dynamic_bypass_sub_cmds/dynamic_bypass_disable (empty) | f336488:c0:m15 |
def _set_dynamic_bypass_disable(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__dynamic_bypass_disable = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for dynamic_bypass_disable, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/dynamic_bypass/mpls_dynamic_bypass_sub_cmds/dynamic_bypass_disable (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_dynamic_bypass_disable is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_dynamic_bypass_disable() directly. | f336488:c0:m16 |
def _get_mpls_dynamic_bypass_sub_cmds(self): | return self.__mpls_dynamic_bypass_sub_cmds<EOL> | Getter method for mpls_dynamic_bypass_sub_cmds, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/dynamic_bypass/mpls_dynamic_bypass_sub_cmds (container) | f336489:c0:m3 |
def _set_mpls_dynamic_bypass_sub_cmds(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=mpls_dynamic_bypass_sub_cmds.mpls_dynamic_bypass_sub_cmds, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__mpls_dynamic_bypass_sub_cmds = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mpls_dynamic_bypass_sub_cmds, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/dynamic_bypass/mpls_dynamic_bypass_sub_cmds (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_mpls_dynamic_bypass_sub_cmds is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mpls_dynamic_bypass_sub_cmds() directly. | f336489:c0:m4 |
def _get_shaping_rate(self): | return self.__shaping_rate<EOL> | Getter method for shaping_rate, mapped from YANG variable /policy_map/class/shape/shaping_rate (shaping-rate-limit) | f336490:c0:m3 |
def _set_shaping_rate(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:64>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__shaping_rate = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for shaping_rate, mapped from YANG variable /policy_map/class/shape/shaping_rate (shaping-rate-limit)
If this variable is read-only (config: false) in the
source YANG file, then _set_shaping_rate is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_shaping_rate() directly. | f336490:c0:m4 |
def _get_cir(self): | return self.__cir<EOL> | Getter method for cir, mapped from YANG variable /policy_map/class/police/cir (uint64) | f336491:c0:m3 |
def _set_cir(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:64>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__cir = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for cir, mapped from YANG variable /policy_map/class/police/cir (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_cir is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_cir() directly. | f336491:c0:m4 |
def _get_cbs(self): | return self.__cbs<EOL> | Getter method for cbs, mapped from YANG variable /policy_map/class/police/cbs (uint64) | f336491:c0:m6 |
def _set_cbs(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:64>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__cbs = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for cbs, mapped from YANG variable /policy_map/class/police/cbs (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_cbs is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_cbs() directly. | f336491:c0:m7 |
def _get_eir(self): | return self.__eir<EOL> | Getter method for eir, mapped from YANG variable /policy_map/class/police/eir (uint64) | f336491:c0:m9 |
def _set_eir(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:64>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__eir = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for eir, mapped from YANG variable /policy_map/class/police/eir (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_eir is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_eir() directly. | f336491:c0:m10 |
def _get_ebs(self): | return self.__ebs<EOL> | Getter method for ebs, mapped from YANG variable /policy_map/class/police/ebs (uint64) | f336491:c0:m12 |
def _set_ebs(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:64>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__ebs = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ebs, mapped from YANG variable /policy_map/class/police/ebs (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_ebs is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ebs() directly. | f336491:c0:m13 |
def _get_classification_type(self): | return self.__classification_type<EOL> | Getter method for classification_type, mapped from YANG variable /policy_map/class/police/classification_type (enumeration) | f336491:c0:m15 |
def _set_classification_type(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:3>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__classification_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for classification_type, mapped from YANG variable /policy_map/class/police/classification_type (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_classification_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_classification_type() directly. | f336491:c0:m16 |
def _get_remark_profile(self): | return self.__remark_profile<EOL> | Getter method for remark_profile, mapped from YANG variable /policy_map/class/police/remark_profile (profile-name-type) | f336491:c0:m18 |
def _set_remark_profile(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>'}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__remark_profile = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for remark_profile, mapped from YANG variable /policy_map/class/police/remark_profile (profile-name-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_remark_profile is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_remark_profile() directly. | f336491:c0:m19 |
def _get_priority_number(self): | return self.__priority_number<EOL> | Getter method for priority_number, mapped from YANG variable /policy_map/class/scheduler/strict_priority/priority_number (uint8) | f336492:c0:m3 |
def _set_priority_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=RestrictedClassType(base_type=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:8>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__priority_number = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for priority_number, mapped from YANG variable /policy_map/class/scheduler/strict_priority/priority_number (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_priority_number is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_priority_number() directly. | f336492:c0:m4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.