signature stringlengths 8 3.44k | body stringlengths 0 1.41M | docstring stringlengths 1 122k | id stringlengths 5 17 |
|---|---|---|---|
def _get_tspec_m(self): | return self.__tspec_m<EOL> | Getter method for tspec_m, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/tspec_m (uint32)
YANG Description: Tspec m | f336465:c0:m54 |
def _set_tspec_m(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.__tspec_m = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for tspec_m, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/tspec_m (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_tspec_m is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tspec_m() directly.
YANG Description: Tspec m | f336465:c0:m55 |
def _get_psb_setup_priority(self): | return self.__psb_setup_priority<EOL> | Getter method for psb_setup_priority, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/psb_setup_priority (uint8)
YANG Description: PSB setup priority | f336465:c0:m57 |
def _set_psb_setup_priority(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=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.__psb_setup_priority = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for psb_setup_priority, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/psb_setup_priority (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_psb_setup_priority is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_psb_setup_priority() directly.
YANG Description: PSB setup priority | f336465:c0:m58 |
def _get_psb_hold_priority(self): | return self.__psb_hold_priority<EOL> | Getter method for psb_hold_priority, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/psb_hold_priority (uint8)
YANG Description: PSB hold priority | f336465:c0:m60 |
def _set_psb_hold_priority(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=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.__psb_hold_priority = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for psb_hold_priority, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/psb_hold_priority (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_psb_hold_priority is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_psb_hold_priority() directly.
YANG Description: PSB hold priority | f336465:c0:m61 |
def _get_session_attribute_all_flags(self): | return self.__session_attribute_all_flags<EOL> | Getter method for session_attribute_all_flags, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/session_attribute_all_flags (uint8)
YANG Description: All session attribute flags | f336465:c0:m63 |
def _set_session_attribute_all_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: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.__session_attribute_all_flags = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for session_attribute_all_flags, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/session_attribute_all_flags (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_session_attribute_all_flags is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_session_attribute_all_flags() directly.
YANG Description: All session attribute flags | f336465:c0:m64 |
def _get_sa_flag_label_recording(self): | return self.__sa_flag_label_recording<EOL> | Getter method for sa_flag_label_recording, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/sa_flag_label_recording (boolean)
YANG Description: Session attribute flag label recording | f336465:c0:m66 |
def _set_sa_flag_label_recording(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.__sa_flag_label_recording = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for sa_flag_label_recording, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/sa_flag_label_recording (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_sa_flag_label_recording is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_sa_flag_label_recording() directly.
YANG Description: Session attribute flag label recording | f336465:c0:m67 |
def _get_sa_flag_soft_preemption_desired(self): | return self.__sa_flag_soft_preemption_desired<EOL> | Getter method for sa_flag_soft_preemption_desired, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/sa_flag_soft_preemption_desired (boolean)
YANG Description: Session attribute flag soft preemption desired | f336465:c0:m69 |
def _set_sa_flag_soft_preemption_desired(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.__sa_flag_soft_preemption_desired = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for sa_flag_soft_preemption_desired, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/sa_flag_soft_preemption_desired (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_sa_flag_soft_preemption_desired is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_sa_flag_soft_preemption_desired() directly.
YANG Description: Session attribute flag soft preemption desired | f336465:c0:m70 |
def _get_sa_flag_se_style(self): | return self.__sa_flag_se_style<EOL> | Getter method for sa_flag_se_style, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/sa_flag_se_style (boolean)
YANG Description: Session attribute flag SE style | f336465:c0:m72 |
def _set_sa_flag_se_style(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.__sa_flag_se_style = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for sa_flag_se_style, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/sa_flag_se_style (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_sa_flag_se_style is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_sa_flag_se_style() directly.
YANG Description: Session attribute flag SE style | f336465:c0:m73 |
def _get_sa_flag_local_protect(self): | return self.__sa_flag_local_protect<EOL> | Getter method for sa_flag_local_protect, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/sa_flag_local_protect (boolean)
YANG Description: Session attribute local protection desired | f336465:c0:m75 |
def _set_sa_flag_local_protect(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.__sa_flag_local_protect = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for sa_flag_local_protect, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/sa_flag_local_protect (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_sa_flag_local_protect is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_sa_flag_local_protect() directly.
YANG Description: Session attribute local protection desired | f336465:c0:m76 |
def _get_sa_flag_bandwidth_protect(self): | return self.__sa_flag_bandwidth_protect<EOL> | Getter method for sa_flag_bandwidth_protect, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/sa_flag_bandwidth_protect (boolean)
YANG Description: Session attribute bandwidth protection desired | f336465:c0:m78 |
def _set_sa_flag_bandwidth_protect(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.__sa_flag_bandwidth_protect = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for sa_flag_bandwidth_protect, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/sa_flag_bandwidth_protect (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_sa_flag_bandwidth_protect is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_sa_flag_bandwidth_protect() directly.
YANG Description: Session attribute bandwidth protection desired | f336465:c0:m79 |
def _get_sa_flag_session_protection_type(self): | return self.__sa_flag_session_protection_type<EOL> | Getter method for sa_flag_session_protection_type, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/sa_flag_session_protection_type (session-protection-type)
YANG Description: Session attribute flag protection type | f336465:c0:m81 |
def _set_sa_flag_session_protection_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:0>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, 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.__sa_flag_session_protection_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for sa_flag_session_protection_type, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/sa_flag_session_protection_type (session-protection-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_sa_flag_session_protection_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_sa_flag_session_protection_type() directly.
YANG Description: Session attribute flag protection type | f336465:c0:m82 |
def _get_session_soft_preemption_wait_timer(self): | return self.__session_soft_preemption_wait_timer<EOL> | Getter method for session_soft_preemption_wait_timer, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/session_soft_preemption_wait_timer (uint32)
YANG Description: Session soft preemption wait timer | f336465:c0:m84 |
def _set_session_soft_preemption_wait_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=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.__session_soft_preemption_wait_timer = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for session_soft_preemption_wait_timer, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/session_soft_preemption_wait_timer (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_session_soft_preemption_wait_timer is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_session_soft_preemption_wait_timer() directly.
YANG Description: Session soft preemption wait timer | f336465:c0:m85 |
def _get_session_preemption_wait_timer(self): | return self.__session_preemption_wait_timer<EOL> | Getter method for session_preemption_wait_timer, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/session_preemption_wait_timer (uint32)
YANG Description: Session preemption wait timer | f336465:c0:m87 |
def _set_session_preemption_wait_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=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.__session_preemption_wait_timer = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for session_preemption_wait_timer, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/session_preemption_wait_timer (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_session_preemption_wait_timer is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_session_preemption_wait_timer() directly.
YANG Description: Session preemption wait timer | f336465:c0:m88 |
def _get_frr_detour(self): | return self.__frr_detour<EOL> | Getter method for frr_detour, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/frr_detour (boolean)
YANG Description: Fast re-route detour | f336465:c0:m90 |
def _set_frr_detour(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.__frr_detour = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for frr_detour, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/frr_detour (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_frr_detour is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_frr_detour() directly.
YANG Description: Fast re-route detour | f336465:c0:m91 |
def _get_frr_facility(self): | return self.__frr_facility<EOL> | Getter method for frr_facility, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/frr_facility (boolean)
YANG Description: Fast re-route facility | f336465:c0:m93 |
def _set_frr_facility(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.__frr_facility = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for frr_facility, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/frr_facility (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_frr_facility is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_frr_facility() directly.
YANG Description: Fast re-route facility | f336465:c0:m94 |
def _get_frr_unknown_backup_mode_desired(self): | return self.__frr_unknown_backup_mode_desired<EOL> | Getter method for frr_unknown_backup_mode_desired, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/frr_unknown_backup_mode_desired (boolean)
YANG Description: Is unknown backup mode desired | f336465:c0:m96 |
def _set_frr_unknown_backup_mode_desired(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.__frr_unknown_backup_mode_desired = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for frr_unknown_backup_mode_desired, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/frr_unknown_backup_mode_desired (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_frr_unknown_backup_mode_desired is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_frr_unknown_backup_mode_desired() directly.
YANG Description: Is unknown backup mode desired | f336465:c0:m97 |
def _get_frr_unknown_flags(self): | return self.__frr_unknown_flags<EOL> | Getter method for frr_unknown_flags, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/frr_unknown_flags (uint8)
YANG Description: Unknown FRR flags | f336465:c0:m99 |
def _set_frr_unknown_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: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.__frr_unknown_flags = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for frr_unknown_flags, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/frr_unknown_flags (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_frr_unknown_flags is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_frr_unknown_flags() directly.
YANG Description: Unknown FRR flags | f336465:c0:m100 |
def _get_frr_psb_setup_priority(self): | return self.__frr_psb_setup_priority<EOL> | Getter method for frr_psb_setup_priority, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/frr_psb_setup_priority (uint8)
YANG Description: FRR PSB setup priority | f336465:c0:m102 |
def _set_frr_psb_setup_priority(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=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.__frr_psb_setup_priority = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for frr_psb_setup_priority, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/frr_psb_setup_priority (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_frr_psb_setup_priority is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_frr_psb_setup_priority() directly.
YANG Description: FRR PSB setup priority | f336465:c0:m103 |
def _get_frr_psb_hold_priority(self): | return self.__frr_psb_hold_priority<EOL> | Getter method for frr_psb_hold_priority, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/frr_psb_hold_priority (uint8)
YANG Description: FRR PSB hold priority | f336465:c0:m105 |
def _set_frr_psb_hold_priority(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=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.__frr_psb_hold_priority = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for frr_psb_hold_priority, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/frr_psb_hold_priority (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_frr_psb_hold_priority is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_frr_psb_hold_priority() directly.
YANG Description: FRR PSB hold priority | f336465:c0:m106 |
def _get_frr_bandwidth(self): | return self.__frr_bandwidth<EOL> | Getter method for frr_bandwidth, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/frr_bandwidth (uint32)
YANG Description: FRR bandwidth | f336465:c0:m108 |
def _set_frr_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.__frr_bandwidth = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for frr_bandwidth, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/frr_bandwidth (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_frr_bandwidth is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_frr_bandwidth() directly.
YANG Description: FRR bandwidth | f336465:c0:m109 |
def _get_frr_hoplimit(self): | return self.__frr_hoplimit<EOL> | Getter method for frr_hoplimit, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/frr_hoplimit (uint8)
YANG Description: FRR hoplimit | f336465:c0:m111 |
def _set_frr_hoplimit(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.__frr_hoplimit = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for frr_hoplimit, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/frr_hoplimit (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_frr_hoplimit is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_frr_hoplimit() directly.
YANG Description: FRR hoplimit | f336465:c0:m112 |
def _get_frr_facility_method(self): | return self.__frr_facility_method<EOL> | Getter method for frr_facility_method, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/frr_facility_method (frr-facility-method)
YANG Description: Whether FRR use backup or detour LSPs | f336465:c0:m114 |
def _set_frr_facility_method(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:0>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, 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_facility_method = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for frr_facility_method, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/frr_facility_method (frr-facility-method)
If this variable is read-only (config: false) in the
source YANG file, then _set_frr_facility_method is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_frr_facility_method() directly.
YANG Description: Whether FRR use backup or detour LSPs | f336465:c0:m115 |
def _get_frr_nh_node_protection_available(self): | return self.__frr_nh_node_protection_available<EOL> | Getter method for frr_nh_node_protection_available, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/frr_nh_node_protection_available (boolean)
YANG Description: FRR nexthop node protection avalable | f336465:c0:m117 |
def _set_frr_nh_node_protection_available(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.__frr_nh_node_protection_available = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for frr_nh_node_protection_available, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/frr_nh_node_protection_available (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_frr_nh_node_protection_available is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_frr_nh_node_protection_available() directly.
YANG Description: FRR nexthop node protection avalable | f336465:c0:m118 |
def _get_frr_nh_node_protection_in_use(self): | return self.__frr_nh_node_protection_in_use<EOL> | Getter method for frr_nh_node_protection_in_use, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/frr_nh_node_protection_in_use (boolean)
YANG Description: FRR nexthop node protection is in use | f336465:c0:m120 |
def _set_frr_nh_node_protection_in_use(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.__frr_nh_node_protection_in_use = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for frr_nh_node_protection_in_use, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/frr_nh_node_protection_in_use (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_frr_nh_node_protection_in_use is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_frr_nh_node_protection_in_use() directly.
YANG Description: FRR nexthop node protection is in use | f336465:c0:m121 |
def _get_frr_nh_link_protection_available(self): | return self.__frr_nh_link_protection_available<EOL> | Getter method for frr_nh_link_protection_available, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/frr_nh_link_protection_available (boolean)
YANG Description: FRR nexthop link protection avalable | f336465:c0:m123 |
def _set_frr_nh_link_protection_available(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.__frr_nh_link_protection_available = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for frr_nh_link_protection_available, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/frr_nh_link_protection_available (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_frr_nh_link_protection_available is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_frr_nh_link_protection_available() directly.
YANG Description: FRR nexthop link protection avalable | f336465:c0:m124 |
def _get_frr_nh_link_protection_in_use(self): | return self.__frr_nh_link_protection_in_use<EOL> | Getter method for frr_nh_link_protection_in_use, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/frr_nh_link_protection_in_use (boolean)
YANG Description: FRR nexthop link protection is in use | f336465:c0:m126 |
def _set_frr_nh_link_protection_in_use(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.__frr_nh_link_protection_in_use = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for frr_nh_link_protection_in_use, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/frr_nh_link_protection_in_use (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_frr_nh_link_protection_in_use is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_frr_nh_link_protection_in_use() directly.
YANG Description: FRR nexthop link protection is in use | f336465:c0:m127 |
def _get_frr_bandwidth_protection_available(self): | return self.__frr_bandwidth_protection_available<EOL> | Getter method for frr_bandwidth_protection_available, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/frr_bandwidth_protection_available (boolean)
YANG Description: FRR bandwidth protection available | f336465:c0:m129 |
def _set_frr_bandwidth_protection_available(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.__frr_bandwidth_protection_available = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for frr_bandwidth_protection_available, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/frr_bandwidth_protection_available (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_frr_bandwidth_protection_available is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_frr_bandwidth_protection_available() directly.
YANG Description: FRR bandwidth protection available | f336465:c0:m130 |
def _get_frr_lsp_bringup_abandoned(self): | return self.__frr_lsp_bringup_abandoned<EOL> | Getter method for frr_lsp_bringup_abandoned, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/frr_lsp_bringup_abandoned (boolean)
YANG Description: Not attempting to bring up FRR LSP (true).Otherwise (false) attempts have failed | f336465:c0:m132 |
def _set_frr_lsp_bringup_abandoned(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.__frr_lsp_bringup_abandoned = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for frr_lsp_bringup_abandoned, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/frr_lsp_bringup_abandoned (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_frr_lsp_bringup_abandoned is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_frr_lsp_bringup_abandoned() directly.
YANG Description: Not attempting to bring up FRR LSP (true).Otherwise (false) attempts have failed | f336465:c0:m133 |
def _get_frr_updown_transitions(self): | return self.__frr_updown_transitions<EOL> | Getter method for frr_updown_transitions, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/frr_updown_transitions (uint32)
YANG Description: FRR up and down transition count | f336465:c0:m135 |
def _set_frr_updown_transitions(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_updown_transitions = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for frr_updown_transitions, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/frr_updown_transitions (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_frr_updown_transitions is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_frr_updown_transitions() directly.
YANG Description: FRR up and down transition count | f336465:c0:m136 |
def _get_frr_retries(self): | return self.__frr_retries<EOL> | Getter method for frr_retries, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/frr_retries (uint32)
YANG Description: FRR retries | f336465:c0:m138 |
def _set_frr_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=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_retries = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for frr_retries, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/frr_retries (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_frr_retries is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_frr_retries() directly.
YANG Description: FRR retries | f336465:c0:m139 |
def _get_frr_session_protection_available(self): | return self.__frr_session_protection_available<EOL> | Getter method for frr_session_protection_available, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/frr_session_protection_available (boolean)
YANG Description: Is FRR protection avalable for the session | f336465:c0:m141 |
def _set_frr_session_protection_available(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.__frr_session_protection_available = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for frr_session_protection_available, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/frr_session_protection_available (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_frr_session_protection_available is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_frr_session_protection_available() directly.
YANG Description: Is FRR protection avalable for the session | f336465:c0:m142 |
def _get_frr_next_retry(self): | return self.__frr_next_retry<EOL> | Getter method for frr_next_retry, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/frr_next_retry (uint32)
YANG Description: FRR next retry | f336465:c0:m144 |
def _set_frr_next_retry(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_next_retry = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for frr_next_retry, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/frr_next_retry (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_frr_next_retry is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_frr_next_retry() directly.
YANG Description: FRR next retry | f336465:c0:m145 |
def _get_frr_cost(self): | return self.__frr_cost<EOL> | Getter method for frr_cost, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/frr_cost (uint32)
YANG Description: FRR cost | f336465:c0:m147 |
def _set_frr_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.__frr_cost = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for frr_cost, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/frr_cost (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_frr_cost is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_frr_cost() directly.
YANG Description: FRR cost | f336465:c0:m148 |
def _get_frr_cspf_group_computation_mode(self): | return self.__frr_cspf_group_computation_mode<EOL> | Getter method for frr_cspf_group_computation_mode, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/frr_cspf_group_computation_mode (frr-cspf-group-computation-mode)
YANG Description: CSPF group computation mode | f336465:c0:m150 |
def _set_frr_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:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:3>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:0>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, 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_cspf_group_computation_mode = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for frr_cspf_group_computation_mode, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/frr_cspf_group_computation_mode (frr-cspf-group-computation-mode)
If this variable is read-only (config: false) in the
source YANG file, then _set_frr_cspf_group_computation_mode is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_frr_cspf_group_computation_mode() directly.
YANG Description: CSPF group computation mode | f336465:c0:m151 |
def _get_frr_cspf_group_computation_mode_use_bypass_liberal(self): | return self.__frr_cspf_group_computation_mode_use_bypass_liberal<EOL> | Getter method for frr_cspf_group_computation_mode_use_bypass_liberal, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/frr_cspf_group_computation_mode_use_bypass_liberal (boolean)
YANG Description: Liberal use of bypasses in CSPF group computation | f336465:c0:m153 |
def _set_frr_cspf_group_computation_mode_use_bypass_liberal(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.__frr_cspf_group_computation_mode_use_bypass_liberal = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for frr_cspf_group_computation_mode_use_bypass_liberal, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/frr_cspf_group_computation_mode_use_bypass_liberal (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_frr_cspf_group_computation_mode_use_bypass_liberal is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_frr_cspf_group_computation_mode_use_bypass_liberal() directly.
YANG Description: Liberal use of bypasses in CSPF group computation | f336465:c0:m154 |
def _get_is_downstream_backup_psb(self): | return self.__is_downstream_backup_psb<EOL> | Getter method for is_downstream_backup_psb, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/is_downstream_backup_psb (boolean)
YANG Description: Is downstream backup PSB | f336465:c0:m156 |
def _set_is_downstream_backup_psb(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.__is_downstream_backup_psb = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for is_downstream_backup_psb, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/is_downstream_backup_psb (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_is_downstream_backup_psb is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_is_downstream_backup_psb() directly.
YANG Description: Is downstream backup PSB | f336465:c0:m157 |
def _get_is_backup_psb(self): | return self.__is_backup_psb<EOL> | Getter method for is_backup_psb, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/is_backup_psb (boolean)
YANG Description: Is backup PSB | f336465:c0:m159 |
def _set_is_backup_psb(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.__is_backup_psb = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for is_backup_psb, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/is_backup_psb (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_is_backup_psb is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_is_backup_psb() directly.
YANG Description: Is backup PSB | f336465:c0:m160 |
def _get_is_upstream_psb(self): | return self.__is_upstream_psb<EOL> | Getter method for is_upstream_psb, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/is_upstream_psb (boolean)
YANG Description: Is upstream PSB | f336465:c0:m162 |
def _set_is_upstream_psb(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.__is_upstream_psb = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for is_upstream_psb, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/is_upstream_psb (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_is_upstream_psb is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_is_upstream_psb() directly.
YANG Description: Is upstream PSB | f336465:c0:m163 |
def _get_is_ps_frr_detour_sent(self): | return self.__is_ps_frr_detour_sent<EOL> | Getter method for is_ps_frr_detour_sent, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/is_ps_frr_detour_sent (boolean)
YANG Description: FRR detours sent | f336465:c0:m165 |
def _set_is_ps_frr_detour_sent(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.__is_ps_frr_detour_sent = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for is_ps_frr_detour_sent, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/is_ps_frr_detour_sent (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_is_ps_frr_detour_sent is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_is_ps_frr_detour_sent() directly.
YANG Description: FRR detours sent | f336465:c0:m166 |
def _get_is_ps_frr_backup_sent(self): | return self.__is_ps_frr_backup_sent<EOL> | Getter method for is_ps_frr_backup_sent, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/is_ps_frr_backup_sent (boolean)
YANG Description: FRR backup sent | f336465:c0:m168 |
def _set_is_ps_frr_backup_sent(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.__is_ps_frr_backup_sent = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for is_ps_frr_backup_sent, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/is_ps_frr_backup_sent (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_is_ps_frr_backup_sent is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_is_ps_frr_backup_sent() directly.
YANG Description: FRR backup sent | f336465:c0:m169 |
def _get_is_ps_frr_detour_received(self): | return self.__is_ps_frr_detour_received<EOL> | Getter method for is_ps_frr_detour_received, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/is_ps_frr_detour_received (boolean)
YANG Description: FRR detours received | f336465:c0:m171 |
def _set_is_ps_frr_detour_received(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.__is_ps_frr_detour_received = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for is_ps_frr_detour_received, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/is_ps_frr_detour_received (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_is_ps_frr_detour_received is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_is_ps_frr_detour_received() directly.
YANG Description: FRR detours received | f336465:c0:m172 |
def _get_is_ps_frr_backup_received(self): | return self.__is_ps_frr_backup_received<EOL> | Getter method for is_ps_frr_backup_received, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/is_ps_frr_backup_received (boolean)
YANG Description: FRR backup received | f336465:c0:m174 |
def _set_is_ps_frr_backup_received(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.__is_ps_frr_backup_received = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for is_ps_frr_backup_received, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/is_ps_frr_backup_received (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_is_ps_frr_backup_received is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_is_ps_frr_backup_received() directly.
YANG Description: FRR backup received | f336465:c0:m175 |
def _get_path_received_from_ip(self): | return self.__path_received_from_ip<EOL> | Getter method for path_received_from_ip, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/path_received_from_ip (inet:ipv4-address)
YANG Description: IP address from which the PATH message was received | f336465:c0:m177 |
def _set_path_received_from_ip(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>'}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, 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_received_from_ip = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for path_received_from_ip, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/path_received_from_ip (inet:ipv4-address)
If this variable is read-only (config: false) in the
source YANG file, then _set_path_received_from_ip is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_path_received_from_ip() directly.
YANG Description: IP address from which the PATH message was received | f336465:c0:m178 |
def _get_path_received_interface(self): | return self.__path_received_interface<EOL> | Getter method for path_received_interface, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/path_received_interface (string)
YANG Description: Interface from which the PATH message was received | f336465:c0:m180 |
def _set_path_received_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.__path_received_interface = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for path_received_interface, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/path_received_interface (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_path_received_interface is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_path_received_interface() directly.
YANG Description: Interface from which the PATH message was received | f336465:c0:m181 |
def _get_path_received_auth_on(self): | return self.__path_received_auth_on<EOL> | Getter method for path_received_auth_on, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/path_received_auth_on (boolean)
YANG Description: Whether authentication (MD5) was used in received PATH message | f336465:c0:m183 |
def _set_path_received_auth_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=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.__path_received_auth_on = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for path_received_auth_on, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/path_received_auth_on (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_path_received_auth_on is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_path_received_auth_on() directly.
YANG Description: Whether authentication (MD5) was used in received PATH message | f336465:c0:m184 |
def _get_path_received_message_id(self): | return self.__path_received_message_id<EOL> | Getter method for path_received_message_id, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/path_received_message_id (uint32)
YANG Description: Message ID received in PATH message | f336465:c0:m186 |
def _set_path_received_message_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.__path_received_message_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for path_received_message_id, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/path_received_message_id (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_path_received_message_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_path_received_message_id() directly.
YANG Description: Message ID received in PATH message | f336465:c0:m187 |
def _get_path_downstream_only(self): | return self.__path_downstream_only<EOL> | Getter method for path_downstream_only, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/path_downstream_only (boolean)
YANG Description: Downstream only | f336465:c0:m189 |
def _set_path_downstream_only(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.__path_downstream_only = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for path_downstream_only, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/path_downstream_only (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_path_downstream_only is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_path_downstream_only() directly.
YANG Description: Downstream only | f336465:c0:m190 |
def _get_path_sent_to_ip(self): | return self.__path_sent_to_ip<EOL> | Getter method for path_sent_to_ip, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/path_sent_to_ip (inet:ipv4-address)
YANG Description: IP address from which the PATH message was sent | f336465:c0:m192 |
def _set_path_sent_to_ip(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>'}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, 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_sent_to_ip = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for path_sent_to_ip, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/path_sent_to_ip (inet:ipv4-address)
If this variable is read-only (config: false) in the
source YANG file, then _set_path_sent_to_ip is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_path_sent_to_ip() directly.
YANG Description: IP address from which the PATH message was sent | f336465:c0:m193 |
def _get_path_sent_interface(self): | return self.__path_sent_interface<EOL> | Getter method for path_sent_interface, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/path_sent_interface (string)
YANG Description: Interface from which the PATH message was sent | f336465:c0:m195 |
def _set_path_sent_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.__path_sent_interface = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for path_sent_interface, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/path_sent_interface (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_path_sent_interface is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_path_sent_interface() directly.
YANG Description: Interface from which the PATH message was sent | f336465:c0:m196 |
def _get_path_sent_auth_on(self): | return self.__path_sent_auth_on<EOL> | Getter method for path_sent_auth_on, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/path_sent_auth_on (boolean)
YANG Description: Whether authentication (MD5) was used in sent PATH message | f336465:c0:m198 |
def _set_path_sent_auth_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=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.__path_sent_auth_on = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for path_sent_auth_on, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/path_sent_auth_on (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_path_sent_auth_on is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_path_sent_auth_on() directly.
YANG Description: Whether authentication (MD5) was used in sent PATH message | f336465:c0:m199 |
def _get_path_sent_message_id(self): | return self.__path_sent_message_id<EOL> | Getter method for path_sent_message_id, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/path_sent_message_id (uint32)
YANG Description: Message ID sent in PATH message | f336465:c0:m201 |
def _set_path_sent_message_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.__path_sent_message_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for path_sent_message_id, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/path_sent_message_id (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_path_sent_message_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_path_sent_message_id() directly.
YANG Description: Message ID sent in PATH message | f336465:c0:m202 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.