signature stringlengths 8 3.44k | body stringlengths 0 1.41M | docstring stringlengths 1 122k | id stringlengths 5 17 |
|---|---|---|---|
def _get_is_md5_auth_enabled(self): | return self.__is_md5_auth_enabled<EOL> | Getter method for is_md5_auth_enabled, mapped from YANG variable /mpls_state/rsvp/interfaces/is_md5_auth_enabled (boolean)
YANG Description: Is MD5 authentication enabled on the interface | f336463:c0:m30 |
def _set_is_md5_auth_enabled(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__is_md5_auth_enabled = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for is_md5_auth_enabled, mapped from YANG variable /mpls_state/rsvp/interfaces/is_md5_auth_enabled (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_is_md5_auth_enabled is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_is_md5_auth_enabled() directly.
YANG Description: Is MD5 authentication enabled on the interface | f336463:c0:m31 |
def _get_reliable_messages(self): | return self.__reliable_messages<EOL> | Getter method for reliable_messages, mapped from YANG variable /mpls_state/rsvp/interfaces/reliable_messages (feature-config-status)
YANG Description: Reliable messaging config on interface | f336463:c0:m33 |
def _set_reliable_messages(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:0>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:3>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:4>}, 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.__reliable_messages = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for reliable_messages, mapped from YANG variable /mpls_state/rsvp/interfaces/reliable_messages (feature-config-status)
If this variable is read-only (config: false) in the
source YANG file, then _set_reliable_messages is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_reliable_messages() directly.
YANG Description: Reliable messaging config on interface | f336463:c0:m34 |
def _get_bundle_messages(self): | return self.__bundle_messages<EOL> | Getter method for bundle_messages, mapped from YANG variable /mpls_state/rsvp/interfaces/bundle_messages (feature-config-status)
YANG Description: Bundle messaging config on interface | f336463:c0:m36 |
def _set_bundle_messages(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:0>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:3>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:4>}, 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.__bundle_messages = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for bundle_messages, mapped from YANG variable /mpls_state/rsvp/interfaces/bundle_messages (feature-config-status)
If this variable is read-only (config: false) in the
source YANG file, then _set_bundle_messages is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_bundle_messages() directly.
YANG Description: Bundle messaging config on interface | f336463:c0:m37 |
def _get_summary_refresh(self): | return self.__summary_refresh<EOL> | Getter method for summary_refresh, mapped from YANG variable /mpls_state/rsvp/interfaces/summary_refresh (feature-config-status)
YANG Description: Summary refresh config on interface | f336463:c0:m39 |
def _set_summary_refresh(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:0>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:3>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:4>}, 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.__summary_refresh = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for summary_refresh, mapped from YANG variable /mpls_state/rsvp/interfaces/summary_refresh (feature-config-status)
If this variable is read-only (config: false) in the
source YANG file, then _set_summary_refresh is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_summary_refresh() directly.
YANG Description: Summary refresh config on interface | f336463:c0:m40 |
def _get_active_outsegs(self): | return self.__active_outsegs<EOL> | Getter method for active_outsegs, mapped from YANG variable /mpls_state/rsvp/interfaces/active_outsegs (uint32)
YANG Description: 1 | f336463:c0:m42 |
def _set_active_outsegs(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.__active_outsegs = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for active_outsegs, mapped from YANG variable /mpls_state/rsvp/interfaces/active_outsegs (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_active_outsegs is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_active_outsegs() directly.
YANG Description: 1 | f336463:c0:m43 |
def _get_inactive_outsegs(self): | return self.__inactive_outsegs<EOL> | Getter method for inactive_outsegs, mapped from YANG variable /mpls_state/rsvp/interfaces/inactive_outsegs (uint32)
YANG Description: 1 | f336463:c0:m45 |
def _set_inactive_outsegs(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.__inactive_outsegs = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for inactive_outsegs, mapped from YANG variable /mpls_state/rsvp/interfaces/inactive_outsegs (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_inactive_outsegs is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_inactive_outsegs() directly.
YANG Description: 1 | f336463:c0:m46 |
def _get_bandwith_resv_outsegs(self): | return self.__bandwith_resv_outsegs<EOL> | Getter method for bandwith_resv_outsegs, mapped from YANG variable /mpls_state/rsvp/interfaces/bandwith_resv_outsegs (uint32)
YANG Description: 1 | f336463:c0:m48 |
def _set_bandwith_resv_outsegs(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.__bandwith_resv_outsegs = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for bandwith_resv_outsegs, mapped from YANG variable /mpls_state/rsvp/interfaces/bandwith_resv_outsegs (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_bandwith_resv_outsegs is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_bandwith_resv_outsegs() directly.
YANG Description: 1 | f336463:c0:m49 |
def _get_active_backup_outsegs(self): | return self.__active_backup_outsegs<EOL> | Getter method for active_backup_outsegs, mapped from YANG variable /mpls_state/rsvp/interfaces/active_backup_outsegs (uint32)
YANG Description: 1 | f336463:c0:m51 |
def _set_active_backup_outsegs(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.__active_backup_outsegs = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for active_backup_outsegs, mapped from YANG variable /mpls_state/rsvp/interfaces/active_backup_outsegs (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_active_backup_outsegs is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_active_backup_outsegs() directly.
YANG Description: 1 | f336463:c0:m52 |
def _get_inactive_backup_outsegs(self): | return self.__inactive_backup_outsegs<EOL> | Getter method for inactive_backup_outsegs, mapped from YANG variable /mpls_state/rsvp/interfaces/inactive_backup_outsegs (uint32)
YANG Description: 1 | f336463:c0:m54 |
def _set_inactive_backup_outsegs(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.__inactive_backup_outsegs = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for inactive_backup_outsegs, mapped from YANG variable /mpls_state/rsvp/interfaces/inactive_backup_outsegs (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_inactive_backup_outsegs is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_inactive_backup_outsegs() directly.
YANG Description: 1 | f336463:c0:m55 |
def _get_interface_preempts(self): | return self.__interface_preempts<EOL> | Getter method for interface_preempts, mapped from YANG variable /mpls_state/rsvp/interfaces/interface_preempts (uint32)
YANG Description: 1 | f336463:c0:m57 |
def _set_interface_preempts(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.__interface_preempts = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for interface_preempts, mapped from YANG variable /mpls_state/rsvp/interfaces/interface_preempts (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_interface_preempts is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_interface_preempts() directly.
YANG Description: 1 | f336463:c0:m58 |
def _get_interface_resv_soft_preempts(self): | return self.__interface_resv_soft_preempts<EOL> | Getter method for interface_resv_soft_preempts, mapped from YANG variable /mpls_state/rsvp/interfaces/interface_resv_soft_preempts (uint32)
YANG Description: 1 | f336463:c0:m60 |
def _set_interface_resv_soft_preempts(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.__interface_resv_soft_preempts = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for interface_resv_soft_preempts, mapped from YANG variable /mpls_state/rsvp/interfaces/interface_resv_soft_preempts (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_interface_resv_soft_preempts is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_interface_resv_soft_preempts() directly.
YANG Description: 1 | f336463:c0:m61 |
def _get_interface_flooding_up_threshold(self): | return self.__interface_flooding_up_threshold<EOL> | Getter method for interface_flooding_up_threshold, mapped from YANG variable /mpls_state/rsvp/interfaces/interface_flooding_up_threshold (feature-config-source)
YANG Description: Interface flood up threshold is taken from global, local or default settings | f336463:c0:m63 |
def _set_interface_flooding_up_threshold(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:3>}, 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.__interface_flooding_up_threshold = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for interface_flooding_up_threshold, mapped from YANG variable /mpls_state/rsvp/interfaces/interface_flooding_up_threshold (feature-config-source)
If this variable is read-only (config: false) in the
source YANG file, then _set_interface_flooding_up_threshold is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_interface_flooding_up_threshold() directly.
YANG Description: Interface flood up threshold is taken from global, local or default settings | f336463:c0:m64 |
def _get_interface_flooding_down_threshold(self): | return self.__interface_flooding_down_threshold<EOL> | Getter method for interface_flooding_down_threshold, mapped from YANG variable /mpls_state/rsvp/interfaces/interface_flooding_down_threshold (feature-config-source)
YANG Description: Interface flood down threshold is taken from global, local or default settings | f336463:c0:m66 |
def _set_interface_flooding_down_threshold(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:3>}, 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.__interface_flooding_down_threshold = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for interface_flooding_down_threshold, mapped from YANG variable /mpls_state/rsvp/interfaces/interface_flooding_down_threshold (feature-config-source)
If this variable is read-only (config: false) in the
source YANG file, then _set_interface_flooding_down_threshold is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_interface_flooding_down_threshold() directly.
YANG Description: Interface flood down threshold is taken from global, local or default settings | f336463:c0:m67 |
def _get_duplicate_preempts_dropped(self): | return self.__duplicate_preempts_dropped<EOL> | Getter method for duplicate_preempts_dropped, mapped from YANG variable /mpls_state/rsvp/interfaces/duplicate_preempts_dropped (uint32)
YANG Description: MPLS RSVP interface duplicate preempts dropped | f336463:c0:m69 |
def _set_duplicate_preempts_dropped(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.__duplicate_preempts_dropped = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for duplicate_preempts_dropped, mapped from YANG variable /mpls_state/rsvp/interfaces/duplicate_preempts_dropped (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_duplicate_preempts_dropped is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_duplicate_preempts_dropped() directly.
YANG Description: MPLS RSVP interface duplicate preempts dropped | f336463:c0:m70 |
def _get_bypass_interface(self): | return self.__bypass_interface<EOL> | Getter method for bypass_interface, mapped from YANG variable /mpls_state/rsvp/interfaces/bypass_interface (boolean)
YANG Description: Bypass interface present | f336463:c0:m72 |
def _set_bypass_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=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.__bypass_interface = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for bypass_interface, mapped from YANG variable /mpls_state/rsvp/interfaces/bypass_interface (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_bypass_interface is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_bypass_interface() directly.
YANG Description: Bypass interface present | f336463:c0:m73 |
def _get_interface_tunnel_name(self): | return self.__interface_tunnel_name<EOL> | Getter method for interface_tunnel_name, mapped from YANG variable /mpls_state/rsvp/interfaces/interface_tunnel_name (string)
YANG Description: Interface tunnel name (if this is a tunnel interface) | f336463:c0:m75 |
def _set_interface_tunnel_name(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__interface_tunnel_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for interface_tunnel_name, mapped from YANG variable /mpls_state/rsvp/interfaces/interface_tunnel_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_interface_tunnel_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_interface_tunnel_name() directly.
YANG Description: Interface tunnel name (if this is a tunnel interface) | f336463:c0:m76 |
def _get_bypass_tunnel_interface_name(self): | return self.__bypass_tunnel_interface_name<EOL> | Getter method for bypass_tunnel_interface_name, mapped from YANG variable /mpls_state/rsvp/interfaces/bypass_tunnel_interface_name (string)
YANG Description: Bypass tunnel interface name | f336463:c0:m78 |
def _set_bypass_tunnel_interface_name(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__bypass_tunnel_interface_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for bypass_tunnel_interface_name, mapped from YANG variable /mpls_state/rsvp/interfaces/bypass_tunnel_interface_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_bypass_tunnel_interface_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_bypass_tunnel_interface_name() directly.
YANG Description: Bypass tunnel interface name | f336463:c0:m79 |
def _get_interface_te_up_thresholds(self): | return self.__interface_te_up_thresholds<EOL> | Getter method for interface_te_up_thresholds, mapped from YANG variable /mpls_state/rsvp/interfaces/interface_te_up_thresholds (uint32)
YANG Description: 1 | f336463:c0:m81 |
def _set_interface_te_up_thresholds(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>)), is_leaf=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__interface_te_up_thresholds = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for interface_te_up_thresholds, mapped from YANG variable /mpls_state/rsvp/interfaces/interface_te_up_thresholds (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_interface_te_up_thresholds is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_interface_te_up_thresholds() directly.
YANG Description: 1 | f336463:c0:m82 |
def _get_interface_te_down_thresholds(self): | return self.__interface_te_down_thresholds<EOL> | Getter method for interface_te_down_thresholds, mapped from YANG variable /mpls_state/rsvp/interfaces/interface_te_down_thresholds (uint32)
YANG Description: 1 | f336463:c0:m84 |
def _set_interface_te_down_thresholds(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>)), is_leaf=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__interface_te_down_thresholds = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for interface_te_down_thresholds, mapped from YANG variable /mpls_state/rsvp/interfaces/interface_te_down_thresholds (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_interface_te_down_thresholds is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_interface_te_down_thresholds() directly.
YANG Description: 1 | f336463:c0:m85 |
def _get_error_counters(self): | return self.__error_counters<EOL> | Getter method for error_counters, mapped from YANG variable /mpls_state/rsvp/interfaces/error_counters (container)
YANG Description: RSVP interface error counters | f336463:c0:m87 |
def _set_error_counters(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=error_counters.error_counters, 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.__error_counters = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for error_counters, mapped from YANG variable /mpls_state/rsvp/interfaces/error_counters (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_error_counters is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_error_counters() directly.
YANG Description: RSVP interface error counters | f336463:c0:m88 |
def _get_packet_counters(self): | return self.__packet_counters<EOL> | Getter method for packet_counters, mapped from YANG variable /mpls_state/rsvp/interfaces/packet_counters (container) | f336463:c0:m90 |
def _set_packet_counters(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=packet_counters.packet_counters, 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>'}}, 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.__packet_counters = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for packet_counters, mapped from YANG variable /mpls_state/rsvp/interfaces/packet_counters (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_packet_counters is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_packet_counters() directly. | f336463:c0:m91 |
def _get_protocol_status(self): | return self.__protocol_status<EOL> | Getter method for protocol_status, mapped from YANG variable /mpls_state/rsvp/protocol_status (boolean)
YANG Description: RSVP protocol status (enabled or disabled) | f336464:c0:m3 |
def _set_protocol_status(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.__protocol_status = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for protocol_status, mapped from YANG variable /mpls_state/rsvp/protocol_status (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_protocol_status is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_protocol_status() directly.
YANG Description: RSVP protocol status (enabled or disabled) | f336464:c0:m4 |
def _get_refresh_interval(self): | return self.__refresh_interval<EOL> | Getter method for refresh_interval, mapped from YANG variable /mpls_state/rsvp/refresh_interval (uint16)
YANG Description: Refresh interval (R) | f336464:c0:m6 |
def _set_refresh_interval(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']},int_size=<NUM_LIT:16>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__refresh_interval = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for refresh_interval, mapped from YANG variable /mpls_state/rsvp/refresh_interval (uint16)
If this variable is read-only (config: false) in the
source YANG file, then _set_refresh_interval is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_refresh_interval() directly.
YANG Description: Refresh interval (R) | f336464:c0:m7 |
def _get_refresh_multiple(self): | return self.__refresh_multiple<EOL> | Getter method for refresh_multiple, mapped from YANG variable /mpls_state/rsvp/refresh_multiple (uint16)
YANG Description: Refresh multiple (K) | f336464:c0:m9 |
def _set_refresh_multiple(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']},int_size=<NUM_LIT:16>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__refresh_multiple = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for refresh_multiple, mapped from YANG variable /mpls_state/rsvp/refresh_multiple (uint16)
If this variable is read-only (config: false) in the
source YANG file, then _set_refresh_multiple is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_refresh_multiple() directly.
YANG Description: Refresh multiple (K) | f336464:c0:m10 |
def _get_transport_address(self): | return self.__transport_address<EOL> | Getter method for transport_address, mapped from YANG variable /mpls_state/rsvp/transport_address (inet:ipv4-address)
YANG Description: Transport Address | f336464:c0:m12 |
def _set_transport_address(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>'}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, 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.__transport_address = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for transport_address, mapped from YANG variable /mpls_state/rsvp/transport_address (inet:ipv4-address)
If this variable is read-only (config: false) in the
source YANG file, then _set_transport_address is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_transport_address() directly.
YANG Description: Transport Address | f336464:c0:m13 |
def _get_delay_resv_sending(self): | return self.__delay_resv_sending<EOL> | Getter method for delay_resv_sending, mapped from YANG variable /mpls_state/rsvp/delay_resv_sending (boolean)
YANG Description: Delayed RESV sending | f336464:c0:m15 |
def _set_delay_resv_sending(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.__delay_resv_sending = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for delay_resv_sending, mapped from YANG variable /mpls_state/rsvp/delay_resv_sending (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_delay_resv_sending is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_delay_resv_sending() directly.
YANG Description: Delayed RESV sending | f336464:c0:m16 |
def _get_backup_bandwidth_requirement(self): | return self.__backup_bandwidth_requirement<EOL> | Getter method for backup_bandwidth_requirement, mapped from YANG variable /mpls_state/rsvp/backup_bandwidth_requirement (boolean)
YANG Description: Backup bandwidth requirement's interpretation | f336464:c0:m18 |
def _set_backup_bandwidth_requirement(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.__backup_bandwidth_requirement = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for backup_bandwidth_requirement, mapped from YANG variable /mpls_state/rsvp/backup_bandwidth_requirement (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_backup_bandwidth_requirement is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_backup_bandwidth_requirement() directly.
YANG Description: Backup bandwidth requirement's interpretation | f336464:c0:m19 |
def _get_msgid_epoch(self): | return self.__msgid_epoch<EOL> | Getter method for msgid_epoch, mapped from YANG variable /mpls_state/rsvp/msgid_epoch (uint32)
YANG Description: Message id epoch | f336464:c0:m21 |
def _set_msgid_epoch(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>)), is_leaf=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__msgid_epoch = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for msgid_epoch, mapped from YANG variable /mpls_state/rsvp/msgid_epoch (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_msgid_epoch is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_msgid_epoch() directly.
YANG Description: Message id epoch | f336464:c0:m22 |
def _get_statistics(self): | return self.__statistics<EOL> | Getter method for statistics, mapped from YANG variable /mpls_state/rsvp/statistics (container)
YANG Description: MPLS RSVP global statistics | f336464:c0:m24 |
def _set_statistics(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=statistics.statistics, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__statistics = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for statistics, mapped from YANG variable /mpls_state/rsvp/statistics (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_statistics is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_statistics() directly.
YANG Description: MPLS RSVP global statistics | f336464:c0:m25 |
def _get_igp_sync(self): | return self.__igp_sync<EOL> | Getter method for igp_sync, mapped from YANG variable /mpls_state/rsvp/igp_sync (container)
YANG Description: MPLS Rsvp IGP Synchronization information | f336464:c0:m27 |
def _set_igp_sync(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=igp_sync.igp_sync, 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.__igp_sync = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for igp_sync, mapped from YANG variable /mpls_state/rsvp/igp_sync (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_igp_sync is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_igp_sync() directly.
YANG Description: MPLS Rsvp IGP Synchronization information | f336464:c0:m28 |
def _get_interfaces(self): | return self.__interfaces<EOL> | Getter method for interfaces, mapped from YANG variable /mpls_state/rsvp/interfaces (list)
YANG Description: MPLS RSVP interface information | f336464:c0:m30 |
def _set_interfaces(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGListType("<STR_LIT>",interfaces.interfaces, 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.__interfaces = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for interfaces, mapped from YANG variable /mpls_state/rsvp/interfaces (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_interfaces is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_interfaces() directly.
YANG Description: MPLS RSVP interface information | f336464:c0:m31 |
def _get_sessions(self): | return self.__sessions<EOL> | Getter method for sessions, mapped from YANG variable /mpls_state/rsvp/sessions (list)
YANG Description: MPLS RSVP Sessions | f336464:c0:m33 |
def _set_sessions(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>",sessions.sessions, 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.__sessions = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for sessions, mapped from YANG variable /mpls_state/rsvp/sessions (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_sessions is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_sessions() directly.
YANG Description: MPLS RSVP Sessions | f336464:c0:m34 |
def _get_neighbors(self): | return self.__neighbors<EOL> | Getter method for neighbors, mapped from YANG variable /mpls_state/rsvp/neighbors (list)
YANG Description: RSVP Neighbor Operational Information | f336464:c0:m36 |
def _set_neighbors(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>",neighbors.neighbors, 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.__neighbors = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for neighbors, mapped from YANG variable /mpls_state/rsvp/neighbors (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_neighbors is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_neighbors() directly.
YANG Description: RSVP Neighbor Operational Information | f336464:c0:m37 |
def _get_path_index(self): | return self.__path_index<EOL> | Getter method for path_index, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/path_index (uint32)
YANG Description: Index of path which is a pseudo key | f336465:c0:m3 |
def _set_path_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.__path_index = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for path_index, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/path_index (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_path_index is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_path_index() directly.
YANG Description: Index of path which is a pseudo key | f336465:c0:m4 |
def _get_session_name(self): | return self.__session_name<EOL> | Getter method for session_name, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/session_name (string)
YANG Description: Session name | f336465:c0:m6 |
def _set_session_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.__session_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for session_name, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/session_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_session_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_session_name() directly.
YANG Description: Session name | f336465:c0:m7 |
def _get_session_type(self): | return self.__session_type<EOL> | Getter method for session_type, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/session_type (session-type)
YANG Description: Session type | f336465:c0:m9 |
def _set_session_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:0>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:6>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:7>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:8>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:9>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:4>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:5>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:3>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__session_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for session_type, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/session_type (session-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_session_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_session_type() directly.
YANG Description: Session type | f336465:c0:m10 |
def _get_path_operational_status(self): | return self.__path_operational_status<EOL> | Getter method for path_operational_status, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/path_operational_status (boolean)
YANG Description: If the path up or not | f336465:c0:m12 |
def _set_path_operational_status(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_operational_status = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for path_operational_status, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/path_operational_status (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_path_operational_status is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_path_operational_status() directly.
YANG Description: If the path up or not | f336465:c0:m13 |
def _get_session_in_label(self): | return self.__session_in_label<EOL> | Getter method for session_in_label, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/session_in_label (uint32)
YANG Description: Session in label | f336465:c0:m15 |
def _set_session_in_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.__session_in_label = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for session_in_label, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/session_in_label (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_session_in_label is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_session_in_label() directly.
YANG Description: Session in label | f336465:c0:m16 |
def _get_session_out_label(self): | return self.__session_out_label<EOL> | Getter method for session_out_label, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/session_out_label (uint32)
YANG Description: Session out label | f336465:c0:m18 |
def _set_session_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.__session_out_label = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for session_out_label, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/session_out_label (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_session_out_label is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_session_out_label() directly.
YANG Description: Session out label | f336465:c0:m19 |
def _get_session_out_interface(self): | return self.__session_out_interface<EOL> | Getter method for session_out_interface, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/session_out_interface (string)
YANG Description: Out-going interface for the session | f336465:c0:m21 |
def _set_session_out_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.__session_out_interface = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for session_out_interface, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/session_out_interface (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_session_out_interface is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_session_out_interface() directly.
YANG Description: Out-going interface for the session | f336465:c0:m22 |
def _get_lsp_id(self): | return self.__lsp_id<EOL> | Getter method for lsp_id, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/lsp_id (uint32)
YANG Description: LSP ID | f336465:c0:m24 |
def _set_lsp_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.__lsp_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for lsp_id, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/lsp_id (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_lsp_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lsp_id() directly.
YANG Description: LSP ID | f336465:c0:m25 |
def _get_flap_lock(self): | return self.__flap_lock<EOL> | Getter method for flap_lock, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/flap_lock (uint32)
YANG Description: Flap lock | f336465:c0:m27 |
def _set_flap_lock(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.__flap_lock = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for flap_lock, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/flap_lock (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_flap_lock is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_flap_lock() directly.
YANG Description: Flap lock | f336465:c0:m28 |
def _get_path_refresh(self): | return self.__path_refresh<EOL> | Getter method for path_refresh, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/path_refresh (uint32)
YANG Description: Path refresh | f336465:c0:m30 |
def _set_path_refresh(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_refresh = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for path_refresh, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/path_refresh (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_path_refresh is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_path_refresh() directly.
YANG Description: Path refresh | f336465:c0:m31 |
def _get_path_refresh_ttd(self): | return self.__path_refresh_ttd<EOL> | Getter method for path_refresh_ttd, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/path_refresh_ttd (uint32)
YANG Description: Path fresesh ttd | f336465:c0:m33 |
def _set_path_refresh_ttd(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_refresh_ttd = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for path_refresh_ttd, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/path_refresh_ttd (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_path_refresh_ttd is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_path_refresh_ttd() directly.
YANG Description: Path fresesh ttd | f336465:c0:m34 |
def _get_resv_refresh(self): | return self.__resv_refresh<EOL> | Getter method for resv_refresh, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/resv_refresh (uint32)
YANG Description: Resv refresh | f336465:c0:m36 |
def _set_resv_refresh(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.__resv_refresh = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for resv_refresh, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/resv_refresh (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_resv_refresh is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_resv_refresh() directly.
YANG Description: Resv refresh | f336465:c0:m37 |
def _get_resv_refresh_ttd(self): | return self.__resv_refresh_ttd<EOL> | Getter method for resv_refresh_ttd, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/resv_refresh_ttd (uint32)
YANG Description: Resv refresh ttd | f336465:c0:m39 |
def _set_resv_refresh_ttd(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.__resv_refresh_ttd = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for resv_refresh_ttd, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/resv_refresh_ttd (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_resv_refresh_ttd is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_resv_refresh_ttd() directly.
YANG Description: Resv refresh ttd | f336465:c0:m40 |
def _get_tspec_peak(self): | return self.__tspec_peak<EOL> | Getter method for tspec_peak, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/tspec_peak (uint32)
YANG Description: Tspec peak | f336465:c0:m42 |
def _set_tspec_peak(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_peak = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for tspec_peak, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/tspec_peak (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_tspec_peak is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tspec_peak() directly.
YANG Description: Tspec peak | f336465:c0:m43 |
def _get_tspec_rate(self): | return self.__tspec_rate<EOL> | Getter method for tspec_rate, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/tspec_rate (uint32)
YANG Description: Tspec rate | f336465:c0:m45 |
def _set_tspec_rate(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=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_rate = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for tspec_rate, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/tspec_rate (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_tspec_rate is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tspec_rate() directly.
YANG Description: Tspec rate | f336465:c0:m46 |
def _get_tspec_size(self): | return self.__tspec_size<EOL> | Getter method for tspec_size, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/tspec_size (uint32)
YANG Description: Tspec size | f336465:c0:m48 |
def _set_tspec_size(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_size = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for tspec_size, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/tspec_size (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_tspec_size is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tspec_size() directly.
YANG Description: Tspec size | f336465:c0:m49 |
def _get_tspec_minimum(self): | return self.__tspec_minimum<EOL> | Getter method for tspec_minimum, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/tspec_minimum (uint32)
YANG Description: Tspec minimum | f336465:c0:m51 |
def _set_tspec_minimum(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_minimum = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for tspec_minimum, mapped from YANG variable /mpls_state/rsvp/sessions/psbs/tspec_minimum (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_tspec_minimum is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tspec_minimum() directly.
YANG Description: Tspec minimum | f336465:c0:m52 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.