signature stringlengths 8 3.44k | body stringlengths 0 1.41M | docstring stringlengths 1 122k | id stringlengths 5 17 |
|---|---|---|---|
def _get_bandwidth_configured(self): | return self.__bandwidth_configured<EOL> | Getter method for bandwidth_configured, mapped from YANG variable /mpls_state/lsp/frr/bandwidth_configured (boolean)
YANG Description: lsp_frr_bandwidth_configured | f336447:c0:m36 |
def _set_bandwidth_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=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.__bandwidth_configured = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for bandwidth_configured, mapped from YANG variable /mpls_state/lsp/frr/bandwidth_configured (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_bandwidth_configured is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_bandwidth_configured() directly.
YANG Description: lsp_frr_bandwidth_configured | f336447:c0:m37 |
def _get_bandwidth(self): | return self.__bandwidth<EOL> | Getter method for bandwidth, mapped from YANG variable /mpls_state/lsp/frr/bandwidth (uint32)
YANG Description: lsp_frr_bandwidth | f336447:c0:m39 |
def _set_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=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.__bandwidth = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for bandwidth, mapped from YANG variable /mpls_state/lsp/frr/bandwidth (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_bandwidth is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_bandwidth() directly.
YANG Description: lsp_frr_bandwidth | f336447:c0:m40 |
def _get_down_reason(self): | return self.__down_reason<EOL> | Getter method for down_reason, mapped from YANG variable /mpls_state/lsp/frr/down_reason (string)
YANG Description: lsp_frr_down_reason | f336447:c0:m42 |
def _set_down_reason(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__down_reason = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for down_reason, mapped from YANG variable /mpls_state/lsp/frr/down_reason (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_down_reason is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_down_reason() directly.
YANG Description: lsp_frr_down_reason | f336447:c0:m43 |
def _get_computation_mode(self): | return self.__computation_mode<EOL> | Getter method for computation_mode, mapped from YANG variable /mpls_state/lsp/frr/computation_mode (lsp-cspf-computation-mode)
YANG Description: lsp frr computation mode | f336447:c0:m45 |
def _set_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>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:7>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:5>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:4>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:3>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:6>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=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.__computation_mode = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for computation_mode, mapped from YANG variable /mpls_state/lsp/frr/computation_mode (lsp-cspf-computation-mode)
If this variable is read-only (config: false) in the
source YANG file, then _set_computation_mode is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_computation_mode() directly.
YANG Description: lsp frr computation mode | f336447:c0:m46 |
def _get_group_computation_mode_default(self): | return self.__group_computation_mode_default<EOL> | Getter method for group_computation_mode_default, mapped from YANG variable /mpls_state/lsp/frr/group_computation_mode_default (boolean)
YANG Description: lsp_frr_group_computation_mode_default | f336447:c0:m48 |
def _set_group_computation_mode_default(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.__group_computation_mode_default = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for group_computation_mode_default, mapped from YANG variable /mpls_state/lsp/frr/group_computation_mode_default (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_group_computation_mode_default is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_group_computation_mode_default() directly.
YANG Description: lsp_frr_group_computation_mode_default | f336447:c0:m49 |
def _get_group_computation_mode_add_penalty(self): | return self.__group_computation_mode_add_penalty<EOL> | Getter method for group_computation_mode_add_penalty, mapped from YANG variable /mpls_state/lsp/frr/group_computation_mode_add_penalty (boolean)
YANG Description: lsp_frr_group_computation_mode_add_penalty | f336447:c0:m51 |
def _set_group_computation_mode_add_penalty(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.__group_computation_mode_add_penalty = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for group_computation_mode_add_penalty, mapped from YANG variable /mpls_state/lsp/frr/group_computation_mode_add_penalty (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_group_computation_mode_add_penalty is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_group_computation_mode_add_penalty() directly.
YANG Description: lsp_frr_group_computation_mode_add_penalty | f336447:c0:m52 |
def _get_group_computation_mode_exclude_groups(self): | return self.__group_computation_mode_exclude_groups<EOL> | Getter method for group_computation_mode_exclude_groups, mapped from YANG variable /mpls_state/lsp/frr/group_computation_mode_exclude_groups (boolean)
YANG Description: lsp_frr_group_computation_mode_exclude_groups | f336447:c0:m54 |
def _set_group_computation_mode_exclude_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=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.__group_computation_mode_exclude_groups = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for group_computation_mode_exclude_groups, mapped from YANG variable /mpls_state/lsp/frr/group_computation_mode_exclude_groups (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_group_computation_mode_exclude_groups is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_group_computation_mode_exclude_groups() directly.
YANG Description: lsp_frr_group_computation_mode_exclude_groups | f336447:c0:m55 |
def _get_group_computation_mode_high_cost(self): | return self.__group_computation_mode_high_cost<EOL> | Getter method for group_computation_mode_high_cost, mapped from YANG variable /mpls_state/lsp/frr/group_computation_mode_high_cost (boolean)
YANG Description: lsp_frr_group_computation_mode_high_cost | f336447:c0:m57 |
def _set_group_computation_mode_high_cost(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=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.__group_computation_mode_high_cost = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for group_computation_mode_high_cost, mapped from YANG variable /mpls_state/lsp/frr/group_computation_mode_high_cost (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_group_computation_mode_high_cost is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_group_computation_mode_high_cost() directly.
YANG Description: lsp_frr_group_computation_mode_high_cost | f336447:c0:m58 |
def _get_out_port_id(self): | return self.__out_port_id<EOL> | Getter method for out_port_id, mapped from YANG variable /mpls_state/lsp/frr/out_port_id (uint32)
YANG Description: lsp_frr_out_port_id | f336447:c0:m60 |
def _set_out_port_id(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT: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.__out_port_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for out_port_id, mapped from YANG variable /mpls_state/lsp/frr/out_port_id (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_out_port_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_out_port_id() directly.
YANG Description: lsp_frr_out_port_id | f336447:c0:m61 |
def _get_out_port_name(self): | return self.__out_port_name<EOL> | Getter method for out_port_name, mapped from YANG variable /mpls_state/lsp/frr/out_port_name (string)
YANG Description: lsp_frr_out_port_name | f336447:c0:m63 |
def _set_out_port_name(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__out_port_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for out_port_name, mapped from YANG variable /mpls_state/lsp/frr/out_port_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_out_port_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_out_port_name() directly.
YANG Description: lsp_frr_out_port_name | f336447:c0:m64 |
def _get_out_label(self): | return self.__out_label<EOL> | Getter method for out_label, mapped from YANG variable /mpls_state/lsp/frr/out_label (uint32)
YANG Description: lsp_frr_out_label | f336447:c0:m66 |
def _set_out_label(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.__out_label = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for out_label, mapped from YANG variable /mpls_state/lsp/frr/out_label (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_out_label is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_out_label() directly.
YANG Description: lsp_frr_out_label | f336447:c0:m67 |
def _get_path_cost(self): | return self.__path_cost<EOL> | Getter method for path_cost, mapped from YANG variable /mpls_state/lsp/frr/path_cost (uint32)
YANG Description: lsp_frr_path_cost | f336447:c0:m69 |
def _set_path_cost(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=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.__path_cost = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for path_cost, mapped from YANG variable /mpls_state/lsp/frr/path_cost (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_path_cost is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_path_cost() directly.
YANG Description: lsp_frr_path_cost | f336447:c0:m70 |
def _get_bypass_name(self): | return self.__bypass_name<EOL> | Getter method for bypass_name, mapped from YANG variable /mpls_state/lsp/frr/bypass_name (string)
YANG Description: lsp_frr_bypass_name | f336447:c0:m72 |
def _set_bypass_name(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__bypass_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for bypass_name, mapped from YANG variable /mpls_state/lsp/frr/bypass_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_bypass_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_bypass_name() directly.
YANG Description: lsp_frr_bypass_name | f336447:c0:m73 |
def _get_has_secondary_swithover_time(self): | return self.__has_secondary_swithover_time<EOL> | Getter method for has_secondary_swithover_time, mapped from YANG variable /mpls_state/lsp/frr/has_secondary_swithover_time (uint32)
YANG Description: lsp_frr_has_secondary_swithover_time | f336447:c0:m75 |
def _set_has_secondary_swithover_time(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=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.__has_secondary_swithover_time = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for has_secondary_swithover_time, mapped from YANG variable /mpls_state/lsp/frr/has_secondary_swithover_time (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_has_secondary_swithover_time is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_has_secondary_swithover_time() directly.
YANG Description: lsp_frr_has_secondary_swithover_time | f336447:c0:m76 |
def _get_secondary_swithover_time(self): | return self.__secondary_swithover_time<EOL> | Getter method for secondary_swithover_time, mapped from YANG variable /mpls_state/lsp/frr/secondary_swithover_time (uint32)
YANG Description: lsp_frr_secondary_swithover_time | f336447:c0:m78 |
def _set_secondary_swithover_time(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=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.__secondary_swithover_time = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for secondary_swithover_time, mapped from YANG variable /mpls_state/lsp/frr/secondary_swithover_time (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_secondary_swithover_time is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_secondary_swithover_time() directly.
YANG Description: lsp_frr_secondary_swithover_time | f336447:c0:m79 |
def _get_hold_time(self): | return self.__hold_time<EOL> | Getter method for hold_time, mapped from YANG variable /mpls_state/lsp/frr/hold_time (uint32)
YANG Description: lsp_frr_hold_time | f336447:c0:m81 |
def _set_hold_time(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=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.__hold_time = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for hold_time, mapped from YANG variable /mpls_state/lsp/frr/hold_time (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_hold_time is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_hold_time() directly.
YANG Description: lsp_frr_hold_time | f336447:c0:m82 |
def _get_global_revertive(self): | return self.__global_revertive<EOL> | Getter method for global_revertive, mapped from YANG variable /mpls_state/lsp/frr/global_revertive (uint32)
YANG Description: lsp_frr_global_revertive | f336447:c0:m84 |
def _set_global_revertive(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.__global_revertive = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for global_revertive, mapped from YANG variable /mpls_state/lsp/frr/global_revertive (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_global_revertive is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_global_revertive() directly.
YANG Description: lsp_frr_global_revertive | f336447:c0:m85 |
def _get_revertive_timer_expired(self): | return self.__revertive_timer_expired<EOL> | Getter method for revertive_timer_expired, mapped from YANG variable /mpls_state/lsp/frr/revertive_timer_expired (uint32)
YANG Description: lsp_frr_revertive_timer_expired | f336447:c0:m87 |
def _set_revertive_timer_expired(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.__revertive_timer_expired = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for revertive_timer_expired, mapped from YANG variable /mpls_state/lsp/frr/revertive_timer_expired (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_revertive_timer_expired is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_revertive_timer_expired() directly.
YANG Description: lsp_frr_revertive_timer_expired | f336447:c0:m88 |
def _get_fwdg_state_primary_up(self): | return self.__fwdg_state_primary_up<EOL> | Getter method for fwdg_state_primary_up, mapped from YANG variable /mpls_state/lsp/frr/fwdg_state_primary_up (boolean)
YANG Description: lsp_frr_fwdg_state_primary_up | f336447:c0:m90 |
def _set_fwdg_state_primary_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=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.__fwdg_state_primary_up = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for fwdg_state_primary_up, mapped from YANG variable /mpls_state/lsp/frr/fwdg_state_primary_up (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_fwdg_state_primary_up is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_fwdg_state_primary_up() directly.
YANG Description: lsp_frr_fwdg_state_primary_up | f336447:c0:m91 |
def _get_fwdg_state_primary_active(self): | return self.__fwdg_state_primary_active<EOL> | Getter method for fwdg_state_primary_active, mapped from YANG variable /mpls_state/lsp/frr/fwdg_state_primary_active (boolean)
YANG Description: lsp_frr_fwdg_state_primary_active | f336447:c0:m93 |
def _set_fwdg_state_primary_active(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.__fwdg_state_primary_active = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for fwdg_state_primary_active, mapped from YANG variable /mpls_state/lsp/frr/fwdg_state_primary_active (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_fwdg_state_primary_active is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_fwdg_state_primary_active() directly.
YANG Description: lsp_frr_fwdg_state_primary_active | f336447:c0:m94 |
def _get_fwdg_state_primary_down(self): | return self.__fwdg_state_primary_down<EOL> | Getter method for fwdg_state_primary_down, mapped from YANG variable /mpls_state/lsp/frr/fwdg_state_primary_down (boolean)
YANG Description: lsp_frr_fwdg_state_primary_down | f336447:c0:m96 |
def _set_fwdg_state_primary_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=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.__fwdg_state_primary_down = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for fwdg_state_primary_down, mapped from YANG variable /mpls_state/lsp/frr/fwdg_state_primary_down (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_fwdg_state_primary_down is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_fwdg_state_primary_down() directly.
YANG Description: lsp_frr_fwdg_state_primary_down | f336447:c0:m97 |
def _get_fwdg_state_secondary_up(self): | return self.__fwdg_state_secondary_up<EOL> | Getter method for fwdg_state_secondary_up, mapped from YANG variable /mpls_state/lsp/frr/fwdg_state_secondary_up (boolean)
YANG Description: lsp_frr_fwdg_state_secondary_up | f336447:c0:m99 |
def _set_fwdg_state_secondary_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=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.__fwdg_state_secondary_up = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for fwdg_state_secondary_up, mapped from YANG variable /mpls_state/lsp/frr/fwdg_state_secondary_up (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_fwdg_state_secondary_up is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_fwdg_state_secondary_up() directly.
YANG Description: lsp_frr_fwdg_state_secondary_up | f336447:c0:m100 |
def _get_fwdg_state_secondary_active(self): | return self.__fwdg_state_secondary_active<EOL> | Getter method for fwdg_state_secondary_active, mapped from YANG variable /mpls_state/lsp/frr/fwdg_state_secondary_active (boolean)
YANG Description: lsp_frr_fwdg_state_secondary_active | f336447:c0:m102 |
def _set_fwdg_state_secondary_active(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.__fwdg_state_secondary_active = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for fwdg_state_secondary_active, mapped from YANG variable /mpls_state/lsp/frr/fwdg_state_secondary_active (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_fwdg_state_secondary_active is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_fwdg_state_secondary_active() directly.
YANG Description: lsp_frr_fwdg_state_secondary_active | f336447:c0:m103 |
def _get_fwdg_state_secondary_down(self): | return self.__fwdg_state_secondary_down<EOL> | Getter method for fwdg_state_secondary_down, mapped from YANG variable /mpls_state/lsp/frr/fwdg_state_secondary_down (boolean)
YANG Description: lsp_frr_fwdg_state_secondary_down | f336447:c0:m105 |
def _set_fwdg_state_secondary_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=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.__fwdg_state_secondary_down = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for fwdg_state_secondary_down, mapped from YANG variable /mpls_state/lsp/frr/fwdg_state_secondary_down (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_fwdg_state_secondary_down is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_fwdg_state_secondary_down() directly.
YANG Description: lsp_frr_fwdg_state_secondary_down | f336447:c0:m106 |
def _get_fwdg_state_detour_up(self): | return self.__fwdg_state_detour_up<EOL> | Getter method for fwdg_state_detour_up, mapped from YANG variable /mpls_state/lsp/frr/fwdg_state_detour_up (boolean)
YANG Description: lsp_frr_fwdg_state_detour_up | f336447:c0:m108 |
def _set_fwdg_state_detour_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=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.__fwdg_state_detour_up = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for fwdg_state_detour_up, mapped from YANG variable /mpls_state/lsp/frr/fwdg_state_detour_up (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_fwdg_state_detour_up is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_fwdg_state_detour_up() directly.
YANG Description: lsp_frr_fwdg_state_detour_up | f336447:c0:m109 |
def _get_fwdg_state_detour_active(self): | return self.__fwdg_state_detour_active<EOL> | Getter method for fwdg_state_detour_active, mapped from YANG variable /mpls_state/lsp/frr/fwdg_state_detour_active (boolean)
YANG Description: lsp_frr_fwdg_state_detour_active | f336447:c0:m111 |
def _set_fwdg_state_detour_active(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.__fwdg_state_detour_active = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for fwdg_state_detour_active, mapped from YANG variable /mpls_state/lsp/frr/fwdg_state_detour_active (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_fwdg_state_detour_active is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_fwdg_state_detour_active() directly.
YANG Description: lsp_frr_fwdg_state_detour_active | f336447:c0:m112 |
def _get_fwdg_state_detour_down(self): | return self.__fwdg_state_detour_down<EOL> | Getter method for fwdg_state_detour_down, mapped from YANG variable /mpls_state/lsp/frr/fwdg_state_detour_down (boolean)
YANG Description: lsp_frr_fwdg_state_detour_active | f336447:c0:m114 |
def _set_fwdg_state_detour_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=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.__fwdg_state_detour_down = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for fwdg_state_detour_down, mapped from YANG variable /mpls_state/lsp/frr/fwdg_state_detour_down (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_fwdg_state_detour_down is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_fwdg_state_detour_down() directly.
YANG Description: lsp_frr_fwdg_state_detour_active | f336447:c0:m115 |
def _get_admin_group_configured(self): | return self.__admin_group_configured<EOL> | Getter method for admin_group_configured, mapped from YANG variable /mpls_state/lsp/frr/admin_group_configured (boolean)
YANG Description: lsp_frr_admin_group_configured | f336447:c0:m117 |
def _set_admin_group_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=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.__admin_group_configured = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for admin_group_configured, mapped from YANG variable /mpls_state/lsp/frr/admin_group_configured (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_admin_group_configured is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_admin_group_configured() directly.
YANG Description: lsp_frr_admin_group_configured | f336447:c0:m118 |
def _get_exclude_any(self): | return self.__exclude_any<EOL> | Getter method for exclude_any, mapped from YANG variable /mpls_state/lsp/frr/exclude_any (list) | f336447:c0:m120 |
def _set_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=YANGListType("<STR_LIT>",exclude_any.exclude_any, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT>', extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>'}}), is_container='<STR_LIT:list>', yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:list>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__exclude_any = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for exclude_any, mapped from YANG variable /mpls_state/lsp/frr/exclude_any (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_exclude_any is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_exclude_any() directly. | f336447:c0:m121 |
def _get_include_any(self): | return self.__include_any<EOL> | Getter method for include_any, mapped from YANG variable /mpls_state/lsp/frr/include_any (list) | f336447:c0:m123 |
def _set_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=YANGListType("<STR_LIT>",include_any.include_any, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT>', extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>'}}), is_container='<STR_LIT:list>', yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:list>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__include_any = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for include_any, mapped from YANG variable /mpls_state/lsp/frr/include_any (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_include_any is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_include_any() directly. | f336447:c0:m124 |
def _get_include_all(self): | return self.__include_all<EOL> | Getter method for include_all, mapped from YANG variable /mpls_state/lsp/frr/include_all (list) | f336447:c0:m126 |
def _set_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=YANGListType("<STR_LIT>",include_all.include_all, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT>', extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>'}}), is_container='<STR_LIT:list>', yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:list>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__include_all = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for include_all, mapped from YANG variable /mpls_state/lsp/frr/include_all (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_include_all is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_include_all() directly. | f336447:c0:m127 |
def _get_admin_group_id(self): | return self.__admin_group_id<EOL> | Getter method for admin_group_id, mapped from YANG variable /mpls_state/lsp/frr/include_all/admin_group_id (uint32)
YANG Description: lsp_admin_group_id | f336448:c0:m3 |
def _set_admin_group_id(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__admin_group_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for admin_group_id, mapped from YANG variable /mpls_state/lsp/frr/include_all/admin_group_id (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_admin_group_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_admin_group_id() directly.
YANG Description: lsp_admin_group_id | f336448:c0:m4 |
def _get_admin_group_name(self): | return self.__admin_group_name<EOL> | Getter method for admin_group_name, mapped from YANG variable /mpls_state/lsp/frr/include_all/admin_group_name (string)
YANG Description: lsp_admin_group_name | f336448:c0:m6 |
def _set_admin_group_name(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__admin_group_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for admin_group_name, mapped from YANG variable /mpls_state/lsp/frr/include_all/admin_group_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_admin_group_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_admin_group_name() directly.
YANG Description: lsp_admin_group_name | f336448:c0:m7 |
def _get_lsp_name(self): | return self.__lsp_name<EOL> | Getter method for lsp_name, mapped from YANG variable /mpls_state/lsp/lsp_name (string)
YANG Description: LSP Name | f336449: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=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__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_state/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.
YANG Description: LSP Name | f336449:c0:m4 |
def _get_lsp_type(self): | return self.__lsp_type<EOL> | Getter method for lsp_type, mapped from YANG variable /mpls_state/lsp/lsp_type (lsp-type)
YANG Description: LSP Type | f336449:c0:m6 |
def _set_lsp_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: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.__lsp_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for lsp_type, mapped from YANG variable /mpls_state/lsp/lsp_type (lsp-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_lsp_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lsp_type() directly.
YANG Description: LSP Type | f336449:c0:m7 |
def _get_bypass_lsp_type(self): | return self.__bypass_lsp_type<EOL> | Getter method for bypass_lsp_type, mapped from YANG variable /mpls_state/lsp/bypass_lsp_type (bypass-lsp-type)
YANG Description: Bypass LSP Type | f336449:c0:m9 |
def _set_bypass_lsp_type(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=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.__bypass_lsp_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for bypass_lsp_type, mapped from YANG variable /mpls_state/lsp/bypass_lsp_type (bypass-lsp-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_bypass_lsp_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_bypass_lsp_type() directly.
YANG Description: Bypass LSP Type | f336449:c0:m10 |
def _get_interface(self): | return self.__interface<EOL> | Getter method for interface, mapped from YANG variable /mpls_state/lsp/interface (string)
YANG Description: Bypass LSP interface | f336449:c0:m12 |
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=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__interface = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for interface, mapped from YANG variable /mpls_state/lsp/interface (string)
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: Bypass LSP interface | f336449:c0:m13 |
def _get_history(self): | return self.__history<EOL> | Getter method for history, mapped from YANG variable /mpls_state/lsp/history (string)
YANG Description: MPLS LSP history Information | f336449:c0:m15 |
def _set_history(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=unicode), is_leaf=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__history = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for history, mapped from YANG variable /mpls_state/lsp/history (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_history is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_history() directly.
YANG Description: MPLS LSP history Information | f336449:c0:m16 |
def _get_basic(self): | return self.__basic<EOL> | Getter method for basic, mapped from YANG variable /mpls_state/lsp/basic (container)
YANG Description: MPLS basic LSP operational information | f336449:c0:m18 |
def _set_basic(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=basic.basic, 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.__basic = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for basic, mapped from YANG variable /mpls_state/lsp/basic (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_basic is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_basic() directly.
YANG Description: MPLS basic LSP operational information | f336449:c0:m19 |
def _get_forwarding(self): | return self.__forwarding<EOL> | Getter method for forwarding, mapped from YANG variable /mpls_state/lsp/forwarding (container)
YANG Description: MPLS LSP forwarding information | f336449:c0:m21 |
def _set_forwarding(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=forwarding.forwarding, 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.__forwarding = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for forwarding, mapped from YANG variable /mpls_state/lsp/forwarding (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_forwarding is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_forwarding() directly.
YANG Description: MPLS LSP forwarding information | f336449:c0:m22 |
def _get_frr(self): | return self.__frr<EOL> | Getter method for frr, mapped from YANG variable /mpls_state/lsp/frr (container)
YANG Description: MPLS LSP FRR information | f336449:c0:m24 |
def _set_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=frr.frr, 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.__frr = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for frr, mapped from YANG variable /mpls_state/lsp/frr (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_frr is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_frr() directly.
YANG Description: MPLS LSP FRR information | f336449:c0:m25 |
def _get_backup(self): | return self.__backup<EOL> | Getter method for backup, mapped from YANG variable /mpls_state/lsp/backup (container)
YANG Description: MPLS LSP detail backup information | f336449:c0:m27 |
def _set_backup(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=backup.backup, 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.__backup = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for backup, mapped from YANG variable /mpls_state/lsp/backup (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_backup is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_backup() directly.
YANG Description: MPLS LSP detail backup information | f336449:c0:m28 |
def _get_instances(self): | return self.__instances<EOL> | Getter method for instances, mapped from YANG variable /mpls_state/lsp/instances (list)
YANG Description: MPLS LSP instancses information | f336449:c0:m30 |
def _set_instances(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>",instances.instances, 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.__instances = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for instances, mapped from YANG variable /mpls_state/lsp/instances (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_instances is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_instances() directly.
YANG Description: MPLS LSP instancses information | f336449:c0:m31 |
def _get_secondary_path(self): | return self.__secondary_path<EOL> | Getter method for secondary_path, mapped from YANG variable /mpls_state/lsp/secondary_path (list)
YANG Description: MPLS LSP secondary path information | f336449:c0:m33 |
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>': 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.__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_state/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.
YANG Description: MPLS LSP secondary path information | f336449:c0:m34 |
def _get_hop_index(self): | return self.__hop_index<EOL> | Getter method for hop_index, mapped from YANG variable /mpls_state/lsp/instances/cspf_exclude_hops/hop_index (uint32)
YANG Description: HOP index | f336450:c0:m3 |
def _set_hop_index(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__hop_index = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for hop_index, mapped from YANG variable /mpls_state/lsp/instances/cspf_exclude_hops/hop_index (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_hop_index is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_hop_index() directly.
YANG Description: HOP index | f336450:c0:m4 |
def _get_hop_address(self): | return self.__hop_address<EOL> | Getter method for hop_address, mapped from YANG variable /mpls_state/lsp/instances/cspf_exclude_hops/hop_address (inet:ipv4-address)
YANG Description: lsp_hop_address | f336450:c0:m6 |
def _set_hop_address(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, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__hop_address = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for hop_address, mapped from YANG variable /mpls_state/lsp/instances/cspf_exclude_hops/hop_address (inet:ipv4-address)
If this variable is read-only (config: false) in the
source YANG file, then _set_hop_address is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_hop_address() directly.
YANG Description: lsp_hop_address | f336450:c0:m7 |
def _get_type(self): | return self.__type<EOL> | Getter method for type, mapped from YANG variable /mpls_state/lsp/instances/cspf_exclude_hops/type (hop-type)
YANG Description: Hop Type | f336450:c0:m9 |
def _set_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:strict>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}},), is_leaf=True, yang_name="<STR_LIT:type>", rest_name="<STR_LIT:type>", 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.__type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for type, mapped from YANG variable /mpls_state/lsp/instances/cspf_exclude_hops/type (hop-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_type() directly.
YANG Description: Hop Type | f336450:c0:m10 |
def _get_hop_is_router_id(self): | return self.__hop_is_router_id<EOL> | Getter method for hop_is_router_id, mapped from YANG variable /mpls_state/lsp/instances/cspf_exclude_hops/hop_is_router_id (boolean)
YANG Description: lsp_hop_is_router_id | f336450:c0:m12 |
def _set_hop_is_router_id(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=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.__hop_is_router_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for hop_is_router_id, mapped from YANG variable /mpls_state/lsp/instances/cspf_exclude_hops/hop_is_router_id (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_hop_is_router_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_hop_is_router_id() directly.
YANG Description: lsp_hop_is_router_id | f336450:c0:m13 |
def _get_protection(self): | return self.__protection<EOL> | Getter method for protection, mapped from YANG variable /mpls_state/lsp/instances/cspf_exclude_hops/protection (boolean)
YANG Description: lsp_hop_has_protection | f336450:c0:m15 |
def _set_protection(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.__protection = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for protection, mapped from YANG variable /mpls_state/lsp/instances/cspf_exclude_hops/protection (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_protection is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_protection() directly.
YANG Description: lsp_hop_has_protection | f336450:c0:m16 |
def _get_node_protection(self): | return self.__node_protection<EOL> | Getter method for node_protection, mapped from YANG variable /mpls_state/lsp/instances/cspf_exclude_hops/node_protection (boolean)
YANG Description: lsp_hop_has_node_protection | f336450:c0:m18 |
def _set_node_protection(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.__node_protection = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for node_protection, mapped from YANG variable /mpls_state/lsp/instances/cspf_exclude_hops/node_protection (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_node_protection is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_node_protection() directly.
YANG Description: lsp_hop_has_node_protection | f336450:c0:m19 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.