signature stringlengths 8 3.44k | body stringlengths 0 1.41M | docstring stringlengths 1 122k | id stringlengths 5 17 |
|---|---|---|---|
def _get_policy(self): | return self.__policy<EOL> | Getter method for policy, mapped from YANG variable /mpls_state/policy (container)
YANG Description: MPLS Policy | f336435:c0:m12 |
def _set_policy(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=policy.policy, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': 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.__policy = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for policy, mapped from YANG variable /mpls_state/policy (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_policy is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_policy() directly.
YANG Description: MPLS Policy | f336435:c0:m13 |
def _get_rsvp(self): | return self.__rsvp<EOL> | Getter method for rsvp, mapped from YANG variable /mpls_state/rsvp (container)
YANG Description: MPLS RSVP Operational Information | f336435:c0:m15 |
def _set_rsvp(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=rsvp.rsvp, 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.__rsvp = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rsvp, mapped from YANG variable /mpls_state/rsvp (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_rsvp is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rsvp() directly.
YANG Description: MPLS RSVP Operational Information | f336435:c0:m16 |
def _get_dynamic_bypass(self): | return self.__dynamic_bypass<EOL> | Getter method for dynamic_bypass, mapped from YANG variable /mpls_state/dynamic_bypass (container)
YANG Description: MPLS dynamic bypass | f336435:c0:m18 |
def _set_dynamic_bypass(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=dynamic_bypass.dynamic_bypass, 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.__dynamic_bypass = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for dynamic_bypass, mapped from YANG variable /mpls_state/dynamic_bypass (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_dynamic_bypass is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_dynamic_bypass() directly.
YANG Description: MPLS dynamic bypass | f336435:c0:m19 |
def _get_te(self): | return self.__te<EOL> | Getter method for te, mapped from YANG variable /mpls_state/te (container)
YANG Description: MPLS Traffic Engineering Operational Information | f336435:c0:m21 |
def _set_te(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=te.te, 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.__te = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for te, mapped from YANG variable /mpls_state/te (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_te is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_te() directly.
YANG Description: MPLS Traffic Engineering Operational Information | f336435:c0:m22 |
def _get_autobw_threshold_table_summary(self): | return self.__autobw_threshold_table_summary<EOL> | Getter method for autobw_threshold_table_summary, mapped from YANG variable /mpls_state/autobw_threshold_table_summary (container)
YANG Description: MPLS Auto Bandwidth Threshold TableSummary | f336435:c0:m24 |
def _set_autobw_threshold_table_summary(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=autobw_threshold_table_summary.autobw_threshold_table_summary, 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.__autobw_threshold_table_summary = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for autobw_threshold_table_summary, mapped from YANG variable /mpls_state/autobw_threshold_table_summary (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_autobw_threshold_table_summary is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_autobw_threshold_table_summary() directly.
YANG Description: MPLS Auto Bandwidth Threshold TableSummary | f336435:c0:m25 |
def _get_statistics_oam(self): | return self.__statistics_oam<EOL> | Getter method for statistics_oam, mapped from YANG variable /mpls_state/statistics_oam (container)
YANG Description: OAM packet statistics | f336435:c0:m27 |
def _set_statistics_oam(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=statistics_oam.statistics_oam, 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.__statistics_oam = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for statistics_oam, mapped from YANG variable /mpls_state/statistics_oam (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_statistics_oam is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_statistics_oam() directly.
YANG Description: OAM packet statistics | f336435:c0:m28 |
def _get_bfd(self): | return self.__bfd<EOL> | Getter method for bfd, mapped from YANG variable /mpls_state/bfd (container)
YANG Description: MPLS BFD | f336435:c0:m30 |
def _set_bfd(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=bfd.bfd, 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.__bfd = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for bfd, mapped from YANG variable /mpls_state/bfd (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_bfd is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_bfd() directly.
YANG Description: MPLS BFD | f336435:c0:m31 |
def _get_interface(self): | return self.__interface<EOL> | Getter method for interface, mapped from YANG variable /mpls_state/interface (list)
YANG Description: MPLS interface information | f336435:c0:m33 |
def _set_interface(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>",interface.interface, 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.__interface = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for interface, mapped from YANG variable /mpls_state/interface (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_interface is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_interface() directly.
YANG Description: MPLS interface information | f336435:c0:m34 |
def _get_path(self): | return self.__path<EOL> | Getter method for path, mapped from YANG variable /mpls_state/path (list)
YANG Description: MPLS Path | f336435:c0:m36 |
def _set_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>",path.path, yang_name="<STR_LIT:path>", rest_name="<STR_LIT:path>", 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:path>", rest_name="<STR_LIT:path>", 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.__path = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for path, mapped from YANG variable /mpls_state/path (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_path is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_path() directly.
YANG Description: MPLS Path | f336435:c0:m37 |
def _get_auto_bandwidth_template(self): | return self.__auto_bandwidth_template<EOL> | Getter method for auto_bandwidth_template, mapped from YANG variable /mpls_state/auto_bandwidth_template (list)
YANG Description: MPLS Auto Bandwidth Template Information | f336435:c0:m39 |
def _set_auto_bandwidth_template(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:name>",auto_bandwidth_template.auto_bandwidth_template, 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:name>', 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.__auto_bandwidth_template = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for auto_bandwidth_template, mapped from YANG variable /mpls_state/auto_bandwidth_template (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_auto_bandwidth_template is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_auto_bandwidth_template() directly.
YANG Description: MPLS Auto Bandwidth Template Information | f336435:c0:m40 |
def _get_autobw_threshold_table_entry(self): | return self.__autobw_threshold_table_entry<EOL> | Getter method for autobw_threshold_table_entry, mapped from YANG variable /mpls_state/autobw_threshold_table_entry (list)
YANG Description: MPLS Auto Bandwidth Threshold Table Information | f336435:c0:m42 |
def _set_autobw_threshold_table_entry(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>",autobw_threshold_table_entry.autobw_threshold_table_entry, 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.__autobw_threshold_table_entry = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for autobw_threshold_table_entry, mapped from YANG variable /mpls_state/autobw_threshold_table_entry (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_autobw_threshold_table_entry is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_autobw_threshold_table_entry() directly.
YANG Description: MPLS Auto Bandwidth Threshold Table Information | f336435:c0:m43 |
def _get_lsp(self): | return self.__lsp<EOL> | Getter method for lsp, mapped from YANG variable /mpls_state/lsp (list)
YANG Description: MPLS LSP operational information | f336435:c0:m45 |
def _set_lsp(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>",lsp.lsp, 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.__lsp = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for lsp, mapped from YANG variable /mpls_state/lsp (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_lsp is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lsp() directly.
YANG Description: MPLS LSP operational information | f336435:c0:m46 |
def _get_forwarding_entry(self): | return self.__forwarding_entry<EOL> | Getter method for forwarding_entry, mapped from YANG variable /mpls_state/forwarding_entry (list)
YANG Description: Forwarding entries created by MPLS | f336435:c0:m48 |
def _set_forwarding_entry(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>",forwarding_entry.forwarding_entry, 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.__forwarding_entry = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for forwarding_entry, mapped from YANG variable /mpls_state/forwarding_entry (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_forwarding_entry is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_forwarding_entry() directly.
YANG Description: Forwarding entries created by MPLS | f336435:c0:m49 |
def _get_route(self): | return self.__route<EOL> | Getter method for route, mapped from YANG variable /mpls_state/route (list)
YANG Description: Routes installed by MPLS | f336435:c0:m51 |
def _set_route(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>",route.route, 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.__route = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for route, mapped from YANG variable /mpls_state/route (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_route is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_route() directly.
YANG Description: Routes installed by MPLS | f336435:c0:m52 |
def _get_tunnel_traffic_statistics(self): | return self.__tunnel_traffic_statistics<EOL> | Getter method for tunnel_traffic_statistics, mapped from YANG variable /mpls_state/tunnel_traffic_statistics (list)
YANG Description: Tunnel Traffic Statistics | f336435:c0:m54 |
def _set_tunnel_traffic_statistics(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:index>",tunnel_traffic_statistics.tunnel_traffic_statistics, 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:index>', 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.__tunnel_traffic_statistics = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for tunnel_traffic_statistics, mapped from YANG variable /mpls_state/tunnel_traffic_statistics (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_tunnel_traffic_statistics is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tunnel_traffic_statistics() directly.
YANG Description: Tunnel Traffic Statistics | f336435:c0:m55 |
def _get_transit_traffic_statistics(self): | return self.__transit_traffic_statistics<EOL> | Getter method for transit_traffic_statistics, mapped from YANG variable /mpls_state/transit_traffic_statistics (list)
YANG Description: Transit Traffic Statistics | f336435:c0:m57 |
def _set_transit_traffic_statistics(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>",transit_traffic_statistics.transit_traffic_statistics, 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.__transit_traffic_statistics = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for transit_traffic_statistics, mapped from YANG variable /mpls_state/transit_traffic_statistics (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_transit_traffic_statistics is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_transit_traffic_statistics() directly.
YANG Description: Transit Traffic Statistics | f336435:c0:m58 |
def _get_cspf_intf(self): | return self.__cspf_intf<EOL> | Getter method for cspf_intf, mapped from YANG variable /mpls_state/policy/cspf_intf (uint8)
YANG Description: CSPF Interface constraint | f336436:c0:m3 |
def _set_cspf_intf(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=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:8>), 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.__cspf_intf = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for cspf_intf, mapped from YANG variable /mpls_state/policy/cspf_intf (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_cspf_intf is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_cspf_intf() directly.
YANG Description: CSPF Interface constraint | f336436:c0:m4 |
def _get_cspf_group_computation_mode(self): | return self.__cspf_group_computation_mode<EOL> | Getter method for cspf_group_computation_mode, mapped from YANG variable /mpls_state/policy/cspf_group_computation_mode (mpls-cspf-grp-comp-mode)
YANG Description: CSPF Group Computation Mode | f336436:c0:m6 |
def _set_cspf_group_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:0>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:4>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:3>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=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.__cspf_group_computation_mode = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for cspf_group_computation_mode, mapped from YANG variable /mpls_state/policy/cspf_group_computation_mode (mpls-cspf-grp-comp-mode)
If this variable is read-only (config: false) in the
source YANG file, then _set_cspf_group_computation_mode is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_cspf_group_computation_mode() directly.
YANG Description: CSPF Group Computation Mode | f336436:c0:m7 |
def _get_cspf_comp_mode(self): | return self.__cspf_comp_mode<EOL> | Getter method for cspf_comp_mode, mapped from YANG variable /mpls_state/policy/cspf_comp_mode (uint32)
YANG Description: CSPF Computation Mode | f336436:c0:m9 |
def _set_cspf_comp_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=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.__cspf_comp_mode = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for cspf_comp_mode, mapped from YANG variable /mpls_state/policy/cspf_comp_mode (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_cspf_comp_mode is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_cspf_comp_mode() directly.
YANG Description: CSPF Computation Mode | f336436:c0:m10 |
def _get_cspf_comp_ignore_overload_bit(self): | return self.__cspf_comp_ignore_overload_bit<EOL> | Getter method for cspf_comp_ignore_overload_bit, mapped from YANG variable /mpls_state/policy/cspf_comp_ignore_overload_bit (uint8)
YANG Description: CSPF Computation Ignore Overload Bit | f336436:c0:m12 |
def _set_cspf_comp_ignore_overload_bit(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=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:8>), 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.__cspf_comp_ignore_overload_bit = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for cspf_comp_ignore_overload_bit, mapped from YANG variable /mpls_state/policy/cspf_comp_ignore_overload_bit (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_cspf_comp_ignore_overload_bit is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_cspf_comp_ignore_overload_bit() directly.
YANG Description: CSPF Computation Ignore Overload Bit | f336436:c0:m13 |
def _get_implicit_commit_value(self): | return self.__implicit_commit_value<EOL> | Getter method for implicit_commit_value, mapped from YANG variable /mpls_state/policy/implicit_commit_value (uint32)
YANG Description: MPLS Implicit Commit value | f336436:c0:m15 |
def _set_implicit_commit_value(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.__implicit_commit_value = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for implicit_commit_value, mapped from YANG variable /mpls_state/policy/implicit_commit_value (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_implicit_commit_value is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_implicit_commit_value() directly.
YANG Description: MPLS Implicit Commit value | f336436:c0:m16 |
def _get_propagate_ttl(self): | return self.__propagate_ttl<EOL> | Getter method for propagate_ttl, mapped from YANG variable /mpls_state/policy/propagate_ttl (uint8)
YANG Description: MPLS Propogate TTL | f336436:c0:m18 |
def _set_propagate_ttl(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=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:8>), 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.__propagate_ttl = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for propagate_ttl, mapped from YANG variable /mpls_state/policy/propagate_ttl (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_propagate_ttl is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_propagate_ttl() directly.
YANG Description: MPLS Propogate TTL | f336436:c0:m19 |
def _get_label_propagate_ttl(self): | return self.__label_propagate_ttl<EOL> | Getter method for label_propagate_ttl, mapped from YANG variable /mpls_state/policy/label_propagate_ttl (uint8)
YANG Description: MPLS Label Propogate TTL | f336436:c0:m21 |
def _set_label_propagate_ttl(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=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:8>), 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.__label_propagate_ttl = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for label_propagate_ttl, mapped from YANG variable /mpls_state/policy/label_propagate_ttl (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_label_propagate_ttl is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_label_propagate_ttl() directly.
YANG Description: MPLS Label Propogate TTL | f336436:c0:m22 |
def _get_vrf_propagate_ttl(self): | return self.__vrf_propagate_ttl<EOL> | Getter method for vrf_propagate_ttl, mapped from YANG variable /mpls_state/policy/vrf_propagate_ttl (uint8)
YANG Description: MPLS VRF Propogate TTL | f336436:c0:m24 |
def _set_vrf_propagate_ttl(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=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:8>), 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.__vrf_propagate_ttl = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vrf_propagate_ttl, mapped from YANG variable /mpls_state/policy/vrf_propagate_ttl (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_vrf_propagate_ttl is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vrf_propagate_ttl() directly.
YANG Description: MPLS VRF Propogate TTL | f336436:c0:m25 |
def _get_rtm_route_filter_enabled(self): | return self.__rtm_route_filter_enabled<EOL> | Getter method for rtm_route_filter_enabled, mapped from YANG variable /mpls_state/policy/rtm_route_filter_enabled (boolean)
YANG Description: RTM route filter enabled | f336436:c0:m27 |
def _set_rtm_route_filter_enabled(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=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.__rtm_route_filter_enabled = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rtm_route_filter_enabled, mapped from YANG variable /mpls_state/policy/rtm_route_filter_enabled (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_rtm_route_filter_enabled is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rtm_route_filter_enabled() directly.
YANG Description: RTM route filter enabled | f336436:c0:m28 |
def _get_rtm_route_filter_all_ibgp_enabled(self): | return self.__rtm_route_filter_all_ibgp_enabled<EOL> | Getter method for rtm_route_filter_all_ibgp_enabled, mapped from YANG variable /mpls_state/policy/rtm_route_filter_all_ibgp_enabled (boolean)
YANG Description: RTM route filter all IBGP enabled | f336436:c0:m30 |
def _set_rtm_route_filter_all_ibgp_enabled(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=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.__rtm_route_filter_all_ibgp_enabled = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rtm_route_filter_all_ibgp_enabled, mapped from YANG variable /mpls_state/policy/rtm_route_filter_all_ibgp_enabled (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_rtm_route_filter_all_ibgp_enabled is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rtm_route_filter_all_ibgp_enabled() directly.
YANG Description: RTM route filter all IBGP enabled | f336436:c0:m31 |
def _get_ingress_tnnl_actg(self): | return self.__ingress_tnnl_actg<EOL> | Getter method for ingress_tnnl_actg, mapped from YANG variable /mpls_state/policy/ingress_tnnl_actg (uint8)
YANG Description: MPLS Ingress Tunnel Accounting | f336436:c0:m33 |
def _set_ingress_tnnl_actg(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=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:8>), 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.__ingress_tnnl_actg = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ingress_tnnl_actg, mapped from YANG variable /mpls_state/policy/ingress_tnnl_actg (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_ingress_tnnl_actg is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ingress_tnnl_actg() directly.
YANG Description: MPLS Ingress Tunnel Accounting | f336436:c0:m34 |
def _get_transit_session_actg(self): | return self.__transit_session_actg<EOL> | Getter method for transit_session_actg, mapped from YANG variable /mpls_state/policy/transit_session_actg (uint8)
YANG Description: MPLS Transit Session Accounting | f336436:c0:m36 |
def _set_transit_session_actg(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=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:8>), 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.__transit_session_actg = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for transit_session_actg, mapped from YANG variable /mpls_state/policy/transit_session_actg (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_transit_session_actg is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_transit_session_actg() directly.
YANG Description: MPLS Transit Session Accounting | f336436:c0:m37 |
def _get_load_interval(self): | return self.__load_interval<EOL> | Getter method for load_interval, mapped from YANG variable /mpls_state/policy/load_interval (uint16)
YANG Description: MPLS Load Interval | f336436:c0:m39 |
def _set_load_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=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']},int_size=<NUM_LIT:16>), 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.__load_interval = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for load_interval, mapped from YANG variable /mpls_state/policy/load_interval (uint16)
If this variable is read-only (config: false) in the
source YANG file, then _set_load_interval is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_load_interval() directly.
YANG Description: MPLS Load Interval | f336436:c0:m40 |
def _get_te_policy_protocol(self): | return self.__te_policy_protocol<EOL> | Getter method for te_policy_protocol, mapped from YANG variable /mpls_state/policy/te_policy_protocol (te-protocol)
YANG Description: MPLS TE Protocol | f336436:c0:m42 |
def _set_te_policy_protocol(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:0>}, 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, 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.__te_policy_protocol = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for te_policy_protocol, mapped from YANG variable /mpls_state/policy/te_policy_protocol (te-protocol)
If this variable is read-only (config: false) in the
source YANG file, then _set_te_policy_protocol is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_te_policy_protocol() directly.
YANG Description: MPLS TE Protocol | f336436:c0:m43 |
def _get_te_policy_flags(self): | return self.__te_policy_flags<EOL> | Getter method for te_policy_flags, mapped from YANG variable /mpls_state/policy/te_policy_flags (uint16)
YANG Description: MPLS TE policy flags | f336436:c0:m45 |
def _set_te_policy_flags(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=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']},int_size=<NUM_LIT:16>), 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.__te_policy_flags = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for te_policy_flags, mapped from YANG variable /mpls_state/policy/te_policy_flags (uint16)
If this variable is read-only (config: false) in the
source YANG file, then _set_te_policy_flags is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_te_policy_flags() directly.
YANG Description: MPLS TE policy flags | f336436:c0:m46 |
def _get_te_policy_area(self): | return self.__te_policy_area<EOL> | Getter method for te_policy_area, mapped from YANG variable /mpls_state/policy/te_policy_area (uint32)
YANG Description: MPLS TE area | f336436:c0:m48 |
def _set_te_policy_area(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.__te_policy_area = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for te_policy_area, mapped from YANG variable /mpls_state/policy/te_policy_area (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_te_policy_area is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_te_policy_area() directly.
YANG Description: MPLS TE area | f336436:c0:m49 |
def _get_handle_isis_nbr_down(self): | return self.__handle_isis_nbr_down<EOL> | Getter method for handle_isis_nbr_down, mapped from YANG variable /mpls_state/policy/handle_isis_nbr_down (uint8)
YANG Description: MPLS Handle ISIS neighbor down | f336436:c0:m51 |
def _set_handle_isis_nbr_down(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=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:8>), 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.__handle_isis_nbr_down = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for handle_isis_nbr_down, mapped from YANG variable /mpls_state/policy/handle_isis_nbr_down (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_handle_isis_nbr_down is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_handle_isis_nbr_down() directly.
YANG Description: MPLS Handle ISIS neighbor down | f336436:c0:m52 |
def _get_handle_ospf_nbr_down(self): | return self.__handle_ospf_nbr_down<EOL> | Getter method for handle_ospf_nbr_down, mapped from YANG variable /mpls_state/policy/handle_ospf_nbr_down (uint8)
YANG Description: MPLS Handle OSPF neighbor down | f336436:c0:m54 |
def _set_handle_ospf_nbr_down(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=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:8>), 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.__handle_ospf_nbr_down = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for handle_ospf_nbr_down, mapped from YANG variable /mpls_state/policy/handle_ospf_nbr_down (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_handle_ospf_nbr_down is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_handle_ospf_nbr_down() directly.
YANG Description: MPLS Handle OSPF neighbor down | f336436:c0:m55 |
def _get_max_lsp_retries(self): | return self.__max_lsp_retries<EOL> | Getter method for max_lsp_retries, mapped from YANG variable /mpls_state/policy/max_lsp_retries (uint16)
YANG Description: MPLS max lsp retries | f336436:c0:m57 |
def _set_max_lsp_retries(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=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']},int_size=<NUM_LIT:16>), 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.__max_lsp_retries = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for max_lsp_retries, mapped from YANG variable /mpls_state/policy/max_lsp_retries (uint16)
If this variable is read-only (config: false) in the
source YANG file, then _set_max_lsp_retries is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_max_lsp_retries() directly.
YANG Description: MPLS max lsp retries | f336436:c0:m58 |
def _get_fast_retry_on(self): | return self.__fast_retry_on<EOL> | Getter method for fast_retry_on, mapped from YANG variable /mpls_state/policy/fast_retry_on (uint8)
YANG Description: MPLS fast retry on | f336436:c0:m60 |
def _set_fast_retry_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=RestrictedClassType(base_type=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:8>), 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.__fast_retry_on = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for fast_retry_on, mapped from YANG variable /mpls_state/policy/fast_retry_on (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_fast_retry_on is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_fast_retry_on() directly.
YANG Description: MPLS fast retry on | f336436:c0:m61 |
def _get_lsp_retry_interval(self): | return self.__lsp_retry_interval<EOL> | Getter method for lsp_retry_interval, mapped from YANG variable /mpls_state/policy/lsp_retry_interval (uint16)
YANG Description: MPLS lsp retry interval | f336436:c0:m63 |
def _set_lsp_retry_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=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']},int_size=<NUM_LIT:16>), 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.__lsp_retry_interval = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for lsp_retry_interval, mapped from YANG variable /mpls_state/policy/lsp_retry_interval (uint16)
If this variable is read-only (config: false) in the
source YANG file, then _set_lsp_retry_interval is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lsp_retry_interval() directly.
YANG Description: MPLS lsp retry interval | f336436:c0:m64 |
def _get_frr_backup_retry_interval(self): | return self.__frr_backup_retry_interval<EOL> | Getter method for frr_backup_retry_interval, mapped from YANG variable /mpls_state/policy/frr_backup_retry_interval (uint32)
YANG Description: MPLS FRR backup retry interval | f336436:c0:m66 |
def _set_frr_backup_retry_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=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.__frr_backup_retry_interval = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for frr_backup_retry_interval, mapped from YANG variable /mpls_state/policy/frr_backup_retry_interval (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_frr_backup_retry_interval is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_frr_backup_retry_interval() directly.
YANG Description: MPLS FRR backup retry interval | f336436:c0:m67 |
def _get_auto_bandwidth_enabled(self): | return self.__auto_bandwidth_enabled<EOL> | Getter method for auto_bandwidth_enabled, mapped from YANG variable /mpls_state/policy/auto_bandwidth_enabled (uint8)
YANG Description: MPLS Autobw | f336436:c0:m69 |
def _set_auto_bandwidth_enabled(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:8>), 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.__auto_bandwidth_enabled = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for auto_bandwidth_enabled, mapped from YANG variable /mpls_state/policy/auto_bandwidth_enabled (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_auto_bandwidth_enabled is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_auto_bandwidth_enabled() directly.
YANG Description: MPLS Autobw | f336436:c0:m70 |
def _get_autobw_sample_interval(self): | return self.__autobw_sample_interval<EOL> | Getter method for autobw_sample_interval, mapped from YANG variable /mpls_state/policy/autobw_sample_interval (uint32)
YANG Description: MPLS Autobw sample interval | f336436:c0:m72 |
def _set_autobw_sample_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=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.__autobw_sample_interval = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for autobw_sample_interval, mapped from YANG variable /mpls_state/policy/autobw_sample_interval (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_autobw_sample_interval is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_autobw_sample_interval() directly.
YANG Description: MPLS Autobw sample interval | f336436:c0:m73 |
def _get_autobw_num_sample_record(self): | return self.__autobw_num_sample_record<EOL> | Getter method for autobw_num_sample_record, mapped from YANG variable /mpls_state/policy/autobw_num_sample_record (uint32)
YANG Description: MPLS Autobw num sample record | f336436:c0:m75 |
def _set_autobw_num_sample_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=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.__autobw_num_sample_record = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for autobw_num_sample_record, mapped from YANG variable /mpls_state/policy/autobw_num_sample_record (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_autobw_num_sample_record is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_autobw_num_sample_record() directly.
YANG Description: MPLS Autobw num sample record | f336436:c0:m76 |
def _get_soft_preempt_cleanup_timer(self): | return self.__soft_preempt_cleanup_timer<EOL> | Getter method for soft_preempt_cleanup_timer, mapped from YANG variable /mpls_state/policy/soft_preempt_cleanup_timer (uint16)
YANG Description: MPLS Soft Preempt cleanup timer | f336436:c0:m78 |
def _set_soft_preempt_cleanup_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=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']},int_size=<NUM_LIT:16>), 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.__soft_preempt_cleanup_timer = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for soft_preempt_cleanup_timer, mapped from YANG variable /mpls_state/policy/soft_preempt_cleanup_timer (uint16)
If this variable is read-only (config: false) in the
source YANG file, then _set_soft_preempt_cleanup_timer is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_soft_preempt_cleanup_timer() directly.
YANG Description: MPLS Soft Preempt cleanup timer | f336436:c0:m79 |
def _get_rsvp_periodic_flooding_timer(self): | return self.__rsvp_periodic_flooding_timer<EOL> | Getter method for rsvp_periodic_flooding_timer, mapped from YANG variable /mpls_state/policy/rsvp_periodic_flooding_timer (uint16)
YANG Description: MPLS RSVP periodic flooding timer | f336436:c0:m81 |
def _set_rsvp_periodic_flooding_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=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']},int_size=<NUM_LIT:16>), 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.__rsvp_periodic_flooding_timer = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rsvp_periodic_flooding_timer, mapped from YANG variable /mpls_state/policy/rsvp_periodic_flooding_timer (uint16)
If this variable is read-only (config: false) in the
source YANG file, then _set_rsvp_periodic_flooding_timer is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rsvp_periodic_flooding_timer() directly.
YANG Description: MPLS RSVP periodic flooding timer | f336436:c0:m82 |
def _get_admin_groups(self): | return self.__admin_groups<EOL> | Getter method for admin_groups, mapped from YANG variable /mpls_state/policy/admin_groups (list)
YANG Description: MPLS Admin Group Entry | f336436:c0:m84 |
def _set_admin_groups(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:name>",admin_groups.admin_groups, 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:name>', 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.__admin_groups = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for admin_groups, mapped from YANG variable /mpls_state/policy/admin_groups (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_admin_groups is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_admin_groups() directly.
YANG Description: MPLS Admin Group Entry | f336436:c0:m85 |
def _get_rsvp_flooding_thresholds(self): | return self.__rsvp_flooding_thresholds<EOL> | Getter method for rsvp_flooding_thresholds, mapped from YANG variable /mpls_state/policy/rsvp_flooding_thresholds (list)
YANG Description: RSVP Flooding Threshold | f336436:c0:m87 |
def _set_rsvp_flooding_thresholds(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>",rsvp_flooding_thresholds.rsvp_flooding_thresholds, 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.__rsvp_flooding_thresholds = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rsvp_flooding_thresholds, mapped from YANG variable /mpls_state/policy/rsvp_flooding_thresholds (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_rsvp_flooding_thresholds is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rsvp_flooding_thresholds() directly.
YANG Description: RSVP Flooding Threshold | f336436:c0:m88 |
def _get_paths_configured(self): | return self.__paths_configured<EOL> | Getter method for paths_configured, mapped from YANG variable /mpls_state/summary/paths_configured (uint32)
YANG Description: Paths configured | f336437:c0:m3 |
def _set_paths_configured(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.__paths_configured = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for paths_configured, mapped from YANG variable /mpls_state/summary/paths_configured (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_paths_configured is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_paths_configured() directly.
YANG Description: Paths configured | f336437:c0:m4 |
def _get_lsps_configured(self): | return self.__lsps_configured<EOL> | Getter method for lsps_configured, mapped from YANG variable /mpls_state/summary/lsps_configured (uint32)
YANG Description: LSPs configured | f336437:c0:m6 |
def _set_lsps_configured(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.__lsps_configured = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for lsps_configured, mapped from YANG variable /mpls_state/summary/lsps_configured (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_lsps_configured is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lsps_configured() directly.
YANG Description: LSPs configured | f336437:c0:m7 |
def _get_lsps_enabled(self): | return self.__lsps_enabled<EOL> | Getter method for lsps_enabled, mapped from YANG variable /mpls_state/summary/lsps_enabled (uint32)
YANG Description: LSPs enabled | f336437:c0:m9 |
def _set_lsps_enabled(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=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.__lsps_enabled = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for lsps_enabled, mapped from YANG variable /mpls_state/summary/lsps_enabled (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_lsps_enabled is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lsps_enabled() directly.
YANG Description: LSPs enabled | f336437:c0:m10 |
def _get_lsps_operational(self): | return self.__lsps_operational<EOL> | Getter method for lsps_operational, mapped from YANG variable /mpls_state/summary/lsps_operational (uint32)
YANG Description: LSPs operational | f336437:c0:m12 |
def _set_lsps_operational(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.__lsps_operational = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for lsps_operational, mapped from YANG variable /mpls_state/summary/lsps_operational (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_lsps_operational is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lsps_operational() directly.
YANG Description: LSPs operational | f336437:c0:m13 |
def _get_detour_lsps_up(self): | return self.__detour_lsps_up<EOL> | Getter method for detour_lsps_up, mapped from YANG variable /mpls_state/summary/detour_lsps_up (uint32)
YANG Description: Detour LSPs UP | f336437:c0:m15 |
def _set_detour_lsps_up(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.__detour_lsps_up = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for detour_lsps_up, mapped from YANG variable /mpls_state/summary/detour_lsps_up (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_detour_lsps_up is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_detour_lsps_up() directly.
YANG Description: Detour LSPs UP | f336437:c0:m16 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.