signature stringlengths 8 3.44k | body stringlengths 0 1.41M | docstring stringlengths 1 122k | id stringlengths 5 17 |
|---|---|---|---|
def _get_instance_down_reason(self): | return self.__instance_down_reason<EOL> | Getter method for instance_down_reason, mapped from YANG variable /mpls_state/lsp/instances/instance_down_reason (string)
YANG Description: lsp_instance_down_reason | f336456:c0:m417 |
def _set_instance_down_reason(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__instance_down_reason = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for instance_down_reason, mapped from YANG variable /mpls_state/lsp/instances/instance_down_reason (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_instance_down_reason is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_instance_down_reason() directly.
YANG Description: lsp_instance_down_reason | f336456:c0:m418 |
def _get_config_exclude_interfaces(self): | return self.__config_exclude_interfaces<EOL> | Getter method for config_exclude_interfaces, mapped from YANG variable /mpls_state/lsp/instances/config_exclude_interfaces (list)
YANG Description: MPLS LSP admin group | f336456:c0:m420 |
def _set_config_exclude_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>",config_exclude_interfaces.config_exclude_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.__config_exclude_interfaces = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for config_exclude_interfaces, mapped from YANG variable /mpls_state/lsp/instances/config_exclude_interfaces (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_config_exclude_interfaces is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_config_exclude_interfaces() directly.
YANG Description: MPLS LSP admin group | f336456:c0:m421 |
def _get_config_exclude_any(self): | return self.__config_exclude_any<EOL> | Getter method for config_exclude_any, mapped from YANG variable /mpls_state/lsp/instances/config_exclude_any (list) | f336456:c0:m423 |
def _set_config_exclude_any(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGListType("<STR_LIT>",config_exclude_any.config_exclude_any, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT>', extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>'}}), is_container='<STR_LIT:list>', yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:list>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__config_exclude_any = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for config_exclude_any, mapped from YANG variable /mpls_state/lsp/instances/config_exclude_any (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_config_exclude_any is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_config_exclude_any() directly. | f336456:c0:m424 |
def _get_config_include_any(self): | return self.__config_include_any<EOL> | Getter method for config_include_any, mapped from YANG variable /mpls_state/lsp/instances/config_include_any (list) | f336456:c0:m426 |
def _set_config_include_any(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGListType("<STR_LIT>",config_include_any.config_include_any, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT>', extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>'}}), is_container='<STR_LIT:list>', yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:list>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__config_include_any = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for config_include_any, mapped from YANG variable /mpls_state/lsp/instances/config_include_any (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_config_include_any is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_config_include_any() directly. | f336456:c0:m427 |
def _get_config_include_all(self): | return self.__config_include_all<EOL> | Getter method for config_include_all, mapped from YANG variable /mpls_state/lsp/instances/config_include_all (list) | f336456:c0:m429 |
def _set_config_include_all(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGListType("<STR_LIT>",config_include_all.config_include_all, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT>', extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>'}}), is_container='<STR_LIT:list>', yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:list>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__config_include_all = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for config_include_all, mapped from YANG variable /mpls_state/lsp/instances/config_include_all (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_config_include_all is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_config_include_all() directly. | f336456:c0:m430 |
def _get_cspf_path_hops(self): | return self.__cspf_path_hops<EOL> | Getter method for cspf_path_hops, mapped from YANG variable /mpls_state/lsp/instances/cspf_path_hops (list) | f336456:c0:m432 |
def _set_cspf_path_hops(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>",cspf_path_hops.cspf_path_hops, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT>', extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>'}}), is_container='<STR_LIT:list>', yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:list>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__cspf_path_hops = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for cspf_path_hops, mapped from YANG variable /mpls_state/lsp/instances/cspf_path_hops (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_cspf_path_hops is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_cspf_path_hops() directly. | f336456:c0:m433 |
def _get_cspf_exclude_hops(self): | return self.__cspf_exclude_hops<EOL> | Getter method for cspf_exclude_hops, mapped from YANG variable /mpls_state/lsp/instances/cspf_exclude_hops (list) | f336456:c0:m435 |
def _set_cspf_exclude_hops(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>",cspf_exclude_hops.cspf_exclude_hops, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT>', extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>'}}), is_container='<STR_LIT:list>', yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:list>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__cspf_exclude_hops = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for cspf_exclude_hops, mapped from YANG variable /mpls_state/lsp/instances/cspf_exclude_hops (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_cspf_exclude_hops is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_cspf_exclude_hops() directly. | f336456:c0:m436 |
def _get_rsvp_session_rro_hops(self): | return self.__rsvp_session_rro_hops<EOL> | Getter method for rsvp_session_rro_hops, mapped from YANG variable /mpls_state/lsp/instances/rsvp_session_rro_hops (list) | f336456:c0:m438 |
def _set_rsvp_session_rro_hops(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGListType("<STR_LIT>",rsvp_session_rro_hops.rsvp_session_rro_hops, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT>', extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>'}}), is_container='<STR_LIT:list>', yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:list>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__rsvp_session_rro_hops = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rsvp_session_rro_hops, mapped from YANG variable /mpls_state/lsp/instances/rsvp_session_rro_hops (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_rsvp_session_rro_hops is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rsvp_session_rro_hops() directly. | f336456:c0:m439 |
def _get_config_frr_exclude_any(self): | return self.__config_frr_exclude_any<EOL> | Getter method for config_frr_exclude_any, mapped from YANG variable /mpls_state/lsp/instances/config_frr_exclude_any (list) | f336456:c0:m441 |
def _set_config_frr_exclude_any(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGListType("<STR_LIT>",config_frr_exclude_any.config_frr_exclude_any, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT>', extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>'}}), is_container='<STR_LIT:list>', yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:list>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__config_frr_exclude_any = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for config_frr_exclude_any, mapped from YANG variable /mpls_state/lsp/instances/config_frr_exclude_any (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_config_frr_exclude_any is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_config_frr_exclude_any() directly. | f336456:c0:m442 |
def _get_config_frr_include_any(self): | return self.__config_frr_include_any<EOL> | Getter method for config_frr_include_any, mapped from YANG variable /mpls_state/lsp/instances/config_frr_include_any (list) | f336456:c0:m444 |
def _set_config_frr_include_any(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGListType("<STR_LIT>",config_frr_include_any.config_frr_include_any, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT>', extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>'}}), is_container='<STR_LIT:list>', yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:list>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__config_frr_include_any = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for config_frr_include_any, mapped from YANG variable /mpls_state/lsp/instances/config_frr_include_any (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_config_frr_include_any is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_config_frr_include_any() directly. | f336456:c0:m445 |
def _get_config_frr_include_all(self): | return self.__config_frr_include_all<EOL> | Getter method for config_frr_include_all, mapped from YANG variable /mpls_state/lsp/instances/config_frr_include_all (list) | f336456:c0:m447 |
def _set_config_frr_include_all(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGListType("<STR_LIT>",config_frr_include_all.config_frr_include_all, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT>', extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>'}}), is_container='<STR_LIT:list>', yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:list>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__config_frr_include_all = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for config_frr_include_all, mapped from YANG variable /mpls_state/lsp/instances/config_frr_include_all (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_config_frr_include_all is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_config_frr_include_all() directly. | f336456:c0:m448 |
def _get_admin_group_id(self): | return self.__admin_group_id<EOL> | Getter method for admin_group_id, mapped from YANG variable /mpls_state/lsp/instances/config_frr_exclude_any/admin_group_id (uint32)
YANG Description: lsp_admin_group_id | f336457:c0:m3 |
def _set_admin_group_id(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__admin_group_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for admin_group_id, mapped from YANG variable /mpls_state/lsp/instances/config_frr_exclude_any/admin_group_id (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_admin_group_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_admin_group_id() directly.
YANG Description: lsp_admin_group_id | f336457:c0:m4 |
def _get_admin_group_name(self): | return self.__admin_group_name<EOL> | Getter method for admin_group_name, mapped from YANG variable /mpls_state/lsp/instances/config_frr_exclude_any/admin_group_name (string)
YANG Description: lsp_admin_group_name | f336457:c0:m6 |
def _set_admin_group_name(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__admin_group_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for admin_group_name, mapped from YANG variable /mpls_state/lsp/instances/config_frr_exclude_any/admin_group_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_admin_group_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_admin_group_name() directly.
YANG Description: lsp_admin_group_name | f336457:c0:m7 |
def _get_hop_index(self): | return self.__hop_index<EOL> | Getter method for hop_index, mapped from YANG variable /mpls_state/lsp/instances/cspf_path_hops/hop_index (uint32)
YANG Description: HOP index | f336458:c0:m3 |
def _set_hop_index(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__hop_index = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for hop_index, mapped from YANG variable /mpls_state/lsp/instances/cspf_path_hops/hop_index (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_hop_index is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_hop_index() directly.
YANG Description: HOP index | f336458:c0:m4 |
def _get_hop_address(self): | return self.__hop_address<EOL> | Getter method for hop_address, mapped from YANG variable /mpls_state/lsp/instances/cspf_path_hops/hop_address (inet:ipv4-address)
YANG Description: lsp_hop_address | f336458:c0:m6 |
def _set_hop_address(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>'}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__hop_address = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for hop_address, mapped from YANG variable /mpls_state/lsp/instances/cspf_path_hops/hop_address (inet:ipv4-address)
If this variable is read-only (config: false) in the
source YANG file, then _set_hop_address is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_hop_address() directly.
YANG Description: lsp_hop_address | f336458:c0:m7 |
def _get_type(self): | return self.__type<EOL> | Getter method for type, mapped from YANG variable /mpls_state/lsp/instances/cspf_path_hops/type (hop-type)
YANG Description: Hop Type | f336458:c0:m9 |
def _set_type(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT:strict>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}},), is_leaf=True, yang_name="<STR_LIT:type>", rest_name="<STR_LIT:type>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for type, mapped from YANG variable /mpls_state/lsp/instances/cspf_path_hops/type (hop-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_type() directly.
YANG Description: Hop Type | f336458:c0:m10 |
def _get_hop_is_router_id(self): | return self.__hop_is_router_id<EOL> | Getter method for hop_is_router_id, mapped from YANG variable /mpls_state/lsp/instances/cspf_path_hops/hop_is_router_id (boolean)
YANG Description: lsp_hop_is_router_id | f336458:c0:m12 |
def _set_hop_is_router_id(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__hop_is_router_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for hop_is_router_id, mapped from YANG variable /mpls_state/lsp/instances/cspf_path_hops/hop_is_router_id (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_hop_is_router_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_hop_is_router_id() directly.
YANG Description: lsp_hop_is_router_id | f336458:c0:m13 |
def _get_protection(self): | return self.__protection<EOL> | Getter method for protection, mapped from YANG variable /mpls_state/lsp/instances/cspf_path_hops/protection (boolean)
YANG Description: lsp_hop_has_protection | f336458:c0:m15 |
def _set_protection(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__protection = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for protection, mapped from YANG variable /mpls_state/lsp/instances/cspf_path_hops/protection (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_protection is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_protection() directly.
YANG Description: lsp_hop_has_protection | f336458:c0:m16 |
def _get_node_protection(self): | return self.__node_protection<EOL> | Getter method for node_protection, mapped from YANG variable /mpls_state/lsp/instances/cspf_path_hops/node_protection (boolean)
YANG Description: lsp_hop_has_node_protection | f336458:c0:m18 |
def _set_node_protection(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__node_protection = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for node_protection, mapped from YANG variable /mpls_state/lsp/instances/cspf_path_hops/node_protection (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_node_protection is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_node_protection() directly.
YANG Description: lsp_hop_has_node_protection | f336458:c0:m19 |
def _get_bandwidth_protection(self): | return self.__bandwidth_protection<EOL> | Getter method for bandwidth_protection, mapped from YANG variable /mpls_state/lsp/instances/cspf_path_hops/bandwidth_protection (boolean)
YANG Description: lsp_hop_has_bandwidth_protection | f336458:c0:m21 |
def _set_bandwidth_protection(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__bandwidth_protection = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for bandwidth_protection, mapped from YANG variable /mpls_state/lsp/instances/cspf_path_hops/bandwidth_protection (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_bandwidth_protection is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_bandwidth_protection() directly.
YANG Description: lsp_hop_has_bandwidth_protection | f336458:c0:m22 |
def _get_protection_in_use(self): | return self.__protection_in_use<EOL> | Getter method for protection_in_use, mapped from YANG variable /mpls_state/lsp/instances/cspf_path_hops/protection_in_use (boolean)
YANG Description: lsp_hop_has_protection_in_use | f336458:c0:m24 |
def _set_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.__protection_in_use = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for protection_in_use, mapped from YANG variable /mpls_state/lsp/instances/cspf_path_hops/protection_in_use (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_protection_in_use is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_protection_in_use() directly.
YANG Description: lsp_hop_has_protection_in_use | f336458:c0:m25 |
def _get_hop_index(self): | return self.__hop_index<EOL> | Getter method for hop_index, mapped from YANG variable /mpls_state/lsp/instances/rsvp_session_rro_hops/hop_index (uint32)
YANG Description: HOP index | f336459:c0:m3 |
def _set_hop_index(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__hop_index = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for hop_index, mapped from YANG variable /mpls_state/lsp/instances/rsvp_session_rro_hops/hop_index (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_hop_index is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_hop_index() directly.
YANG Description: HOP index | f336459:c0:m4 |
def _get_hop_address(self): | return self.__hop_address<EOL> | Getter method for hop_address, mapped from YANG variable /mpls_state/lsp/instances/rsvp_session_rro_hops/hop_address (inet:ipv4-address)
YANG Description: lsp_hop_address | f336459:c0:m6 |
def _set_hop_address(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>'}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__hop_address = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for hop_address, mapped from YANG variable /mpls_state/lsp/instances/rsvp_session_rro_hops/hop_address (inet:ipv4-address)
If this variable is read-only (config: false) in the
source YANG file, then _set_hop_address is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_hop_address() directly.
YANG Description: lsp_hop_address | f336459:c0:m7 |
def _get_type(self): | return self.__type<EOL> | Getter method for type, mapped from YANG variable /mpls_state/lsp/instances/rsvp_session_rro_hops/type (hop-type)
YANG Description: Hop Type | f336459:c0:m9 |
def _set_type(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT:strict>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}},), is_leaf=True, yang_name="<STR_LIT:type>", rest_name="<STR_LIT:type>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for type, mapped from YANG variable /mpls_state/lsp/instances/rsvp_session_rro_hops/type (hop-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_type() directly.
YANG Description: Hop Type | f336459:c0:m10 |
def _get_hop_is_router_id(self): | return self.__hop_is_router_id<EOL> | Getter method for hop_is_router_id, mapped from YANG variable /mpls_state/lsp/instances/rsvp_session_rro_hops/hop_is_router_id (boolean)
YANG Description: lsp_hop_is_router_id | f336459:c0:m12 |
def _set_hop_is_router_id(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__hop_is_router_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for hop_is_router_id, mapped from YANG variable /mpls_state/lsp/instances/rsvp_session_rro_hops/hop_is_router_id (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_hop_is_router_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_hop_is_router_id() directly.
YANG Description: lsp_hop_is_router_id | f336459:c0:m13 |
def _get_protection(self): | return self.__protection<EOL> | Getter method for protection, mapped from YANG variable /mpls_state/lsp/instances/rsvp_session_rro_hops/protection (boolean)
YANG Description: lsp_hop_has_protection | f336459:c0:m15 |
def _set_protection(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__protection = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for protection, mapped from YANG variable /mpls_state/lsp/instances/rsvp_session_rro_hops/protection (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_protection is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_protection() directly.
YANG Description: lsp_hop_has_protection | f336459:c0:m16 |
def _get_node_protection(self): | return self.__node_protection<EOL> | Getter method for node_protection, mapped from YANG variable /mpls_state/lsp/instances/rsvp_session_rro_hops/node_protection (boolean)
YANG Description: lsp_hop_has_node_protection | f336459:c0:m18 |
def _set_node_protection(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__node_protection = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for node_protection, mapped from YANG variable /mpls_state/lsp/instances/rsvp_session_rro_hops/node_protection (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_node_protection is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_node_protection() directly.
YANG Description: lsp_hop_has_node_protection | f336459:c0:m19 |
def _get_bandwidth_protection(self): | return self.__bandwidth_protection<EOL> | Getter method for bandwidth_protection, mapped from YANG variable /mpls_state/lsp/instances/rsvp_session_rro_hops/bandwidth_protection (boolean)
YANG Description: lsp_hop_has_bandwidth_protection | f336459:c0:m21 |
def _set_bandwidth_protection(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__bandwidth_protection = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for bandwidth_protection, mapped from YANG variable /mpls_state/lsp/instances/rsvp_session_rro_hops/bandwidth_protection (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_bandwidth_protection is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_bandwidth_protection() directly.
YANG Description: lsp_hop_has_bandwidth_protection | f336459:c0:m22 |
def _get_protection_in_use(self): | return self.__protection_in_use<EOL> | Getter method for protection_in_use, mapped from YANG variable /mpls_state/lsp/instances/rsvp_session_rro_hops/protection_in_use (boolean)
YANG Description: lsp_hop_has_protection_in_use | f336459:c0:m24 |
def _set_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.__protection_in_use = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for protection_in_use, mapped from YANG variable /mpls_state/lsp/instances/rsvp_session_rro_hops/protection_in_use (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_protection_in_use is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_protection_in_use() directly.
YANG Description: lsp_hop_has_protection_in_use | f336459:c0:m25 |
def _get_exclude_interface_name(self): | return self.__exclude_interface_name<EOL> | Getter method for exclude_interface_name, mapped from YANG variable /mpls_state/lsp/instances/config_exclude_interfaces/exclude_interface_name (string)
YANG Description: lsp_exclude_interface_name | f336460:c0:m3 |
def _set_exclude_interface_name(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__exclude_interface_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for exclude_interface_name, mapped from YANG variable /mpls_state/lsp/instances/config_exclude_interfaces/exclude_interface_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_exclude_interface_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_exclude_interface_name() directly.
YANG Description: lsp_exclude_interface_name | f336460:c0:m4 |
def _get_number_of_packets(self): | return self.__number_of_packets<EOL> | Getter method for number_of_packets, mapped from YANG variable /mpls_state/transit_traffic_statistics/statistics/number_of_packets (uint64)
YANG Description: Total number of packets | f336461:c0:m3 |
def _set_number_of_packets(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:64>), 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.__number_of_packets = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for number_of_packets, mapped from YANG variable /mpls_state/transit_traffic_statistics/statistics/number_of_packets (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_number_of_packets is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_number_of_packets() directly.
YANG Description: Total number of packets | f336461:c0:m4 |
def _get_number_of_packets_since_clear(self): | return self.__number_of_packets_since_clear<EOL> | Getter method for number_of_packets_since_clear, mapped from YANG variable /mpls_state/transit_traffic_statistics/statistics/number_of_packets_since_clear (uint64)
YANG Description: Total number of packets since lst clear | f336461:c0:m6 |
def _set_number_of_packets_since_clear(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:64>), 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.__number_of_packets_since_clear = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for number_of_packets_since_clear, mapped from YANG variable /mpls_state/transit_traffic_statistics/statistics/number_of_packets_since_clear (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_number_of_packets_since_clear is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_number_of_packets_since_clear() directly.
YANG Description: Total number of packets since lst clear | f336461:c0:m7 |
def _get_number_of_bytes(self): | return self.__number_of_bytes<EOL> | Getter method for number_of_bytes, mapped from YANG variable /mpls_state/transit_traffic_statistics/statistics/number_of_bytes (uint64)
YANG Description: Total number of bytes | f336461:c0:m9 |
def _set_number_of_bytes(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:64>), 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.__number_of_bytes = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for number_of_bytes, mapped from YANG variable /mpls_state/transit_traffic_statistics/statistics/number_of_bytes (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_number_of_bytes is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_number_of_bytes() directly.
YANG Description: Total number of bytes | f336461:c0:m10 |
def _get_number_of_bytes_since_clear(self): | return self.__number_of_bytes_since_clear<EOL> | Getter method for number_of_bytes_since_clear, mapped from YANG variable /mpls_state/transit_traffic_statistics/statistics/number_of_bytes_since_clear (uint64)
YANG Description: Total number of bytes since last clear | f336461:c0:m12 |
def _set_number_of_bytes_since_clear(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:64>), 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.__number_of_bytes_since_clear = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for number_of_bytes_since_clear, mapped from YANG variable /mpls_state/transit_traffic_statistics/statistics/number_of_bytes_since_clear (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_number_of_bytes_since_clear is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_number_of_bytes_since_clear() directly.
YANG Description: Total number of bytes since last clear | f336461:c0:m13 |
def _get_packets_per_second(self): | return self.__packets_per_second<EOL> | Getter method for packets_per_second, mapped from YANG variable /mpls_state/transit_traffic_statistics/statistics/packets_per_second (uint64)
YANG Description: Packets per second | f336461:c0:m15 |
def _set_packets_per_second(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:64>), 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.__packets_per_second = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for packets_per_second, mapped from YANG variable /mpls_state/transit_traffic_statistics/statistics/packets_per_second (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_packets_per_second is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_packets_per_second() directly.
YANG Description: Packets per second | f336461:c0:m16 |
def _get_bytes_per_second(self): | return self.__bytes_per_second<EOL> | Getter method for bytes_per_second, mapped from YANG variable /mpls_state/transit_traffic_statistics/statistics/bytes_per_second (uint64)
YANG Description: Bytes per second | f336461:c0:m18 |
def _set_bytes_per_second(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:64>), 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.__bytes_per_second = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for bytes_per_second, mapped from YANG variable /mpls_state/transit_traffic_statistics/statistics/bytes_per_second (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_bytes_per_second is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_bytes_per_second() directly.
YANG Description: Bytes per second | f336461:c0:m19 |
def _get_averaging_interval_seconds(self): | return self.__averaging_interval_seconds<EOL> | Getter method for averaging_interval_seconds, mapped from YANG variable /mpls_state/transit_traffic_statistics/statistics/averaging_interval_seconds (uint32)
YANG Description: Averaging Interval | f336461:c0:m21 |
def _set_averaging_interval_seconds(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.__averaging_interval_seconds = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for averaging_interval_seconds, mapped from YANG variable /mpls_state/transit_traffic_statistics/statistics/averaging_interval_seconds (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_averaging_interval_seconds is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_averaging_interval_seconds() directly.
YANG Description: Averaging Interval | f336461:c0:m22 |
def _get_in_label(self): | return self.__in_label<EOL> | Getter method for in_label, mapped from YANG variable /mpls_state/transit_traffic_statistics/in_label (uint32)
YANG Description: In Label | f336462:c0:m3 |
def _set_in_label(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.__in_label = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for in_label, mapped from YANG variable /mpls_state/transit_traffic_statistics/in_label (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_in_label is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_in_label() directly.
YANG Description: In Label | f336462:c0:m4 |
def _get_protocol(self): | return self.__protocol<EOL> | Getter method for protocol, mapped from YANG variable /mpls_state/transit_traffic_statistics/protocol (mpls-protocol)
YANG Description: MPLS protocol | f336462:c0:m6 |
def _set_protocol(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:0>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__protocol = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for protocol, mapped from YANG variable /mpls_state/transit_traffic_statistics/protocol (mpls-protocol)
If this variable is read-only (config: false) in the
source YANG file, then _set_protocol is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_protocol() directly.
YANG Description: MPLS protocol | f336462:c0:m7 |
def _get_statistics_valid(self): | return self.__statistics_valid<EOL> | Getter method for statistics_valid, mapped from YANG variable /mpls_state/transit_traffic_statistics/statistics_valid (boolean)
YANG Description: Statistics are valid | f336462:c0:m9 |
def _set_statistics_valid(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.__statistics_valid = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for statistics_valid, mapped from YANG variable /mpls_state/transit_traffic_statistics/statistics_valid (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_statistics_valid is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_statistics_valid() directly.
YANG Description: Statistics are valid | f336462:c0:m10 |
def _get_statistics(self): | return self.__statistics<EOL> | Getter method for statistics, mapped from YANG variable /mpls_state/transit_traffic_statistics/statistics (container) | f336462:c0:m12 |
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>'}}, 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/transit_traffic_statistics/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. | f336462:c0:m13 |
def _get_interface_name(self): | return self.__interface_name<EOL> | Getter method for interface_name, mapped from YANG variable /mpls_state/rsvp/interfaces/interface_name (string)
YANG Description: MPLS RSVP interface name | f336463:c0:m3 |
def _set_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.__interface_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for interface_name, mapped from YANG variable /mpls_state/rsvp/interfaces/interface_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_interface_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_interface_name() directly.
YANG Description: MPLS RSVP interface name | f336463:c0:m4 |
def _get_interface_type(self): | return self.__interface_type<EOL> | Getter method for interface_type, mapped from YANG variable /mpls_state/rsvp/interfaces/interface_type (dcm-interface-type)
YANG Description: MPLS RSVP interface type | f336463:c0:m6 |
def _set_interface_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:7>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:6>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:8>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:5>}},), 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_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for interface_type, mapped from YANG variable /mpls_state/rsvp/interfaces/interface_type (dcm-interface-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_interface_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_interface_type() directly.
YANG Description: MPLS RSVP interface type | f336463:c0:m7 |
def _get_interface_index(self): | return self.__interface_index<EOL> | Getter method for interface_index, mapped from YANG variable /mpls_state/rsvp/interfaces/interface_index (uint32)
YANG Description: MPLS RSVP interface ID | f336463:c0:m9 |
def _set_interface_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.__interface_index = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for interface_index, mapped from YANG variable /mpls_state/rsvp/interfaces/interface_index (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_interface_index is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_interface_index() directly.
YANG Description: MPLS RSVP interface ID | f336463:c0:m10 |
def _get_admin_status(self): | return self.__admin_status<EOL> | Getter method for admin_status, mapped from YANG variable /mpls_state/rsvp/interfaces/admin_status (boolean)
YANG Description: MPLS RSVP interface admin status | f336463:c0:m12 |
def _set_admin_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.__admin_status = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for admin_status, mapped from YANG variable /mpls_state/rsvp/interfaces/admin_status (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_admin_status is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_admin_status() directly.
YANG Description: MPLS RSVP interface admin status | f336463:c0:m13 |
def _get_oper_status(self): | return self.__oper_status<EOL> | Getter method for oper_status, mapped from YANG variable /mpls_state/rsvp/interfaces/oper_status (boolean)
YANG Description: MPLS RSVP interface operational status | f336463:c0:m15 |
def _set_oper_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.__oper_status = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for oper_status, mapped from YANG variable /mpls_state/rsvp/interfaces/oper_status (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_oper_status is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_oper_status() directly.
YANG Description: MPLS RSVP interface operational status | f336463:c0:m16 |
def _get_is_tunnel_interface(self): | return self.__is_tunnel_interface<EOL> | Getter method for is_tunnel_interface, mapped from YANG variable /mpls_state/rsvp/interfaces/is_tunnel_interface (boolean)
YANG Description: Is this a tunnle interface | f336463:c0:m18 |
def _set_is_tunnel_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.__is_tunnel_interface = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for is_tunnel_interface, mapped from YANG variable /mpls_state/rsvp/interfaces/is_tunnel_interface (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_is_tunnel_interface is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_is_tunnel_interface() directly.
YANG Description: Is this a tunnle interface | f336463:c0:m19 |
def _get_hello_interval(self): | return self.__hello_interval<EOL> | Getter method for hello_interval, mapped from YANG variable /mpls_state/rsvp/interfaces/hello_interval (uint32)
YANG Description: MPLS RSVP interface hello interval | f336463:c0:m21 |
def _set_hello_interval(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__hello_interval = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for hello_interval, mapped from YANG variable /mpls_state/rsvp/interfaces/hello_interval (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_hello_interval is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_hello_interval() directly.
YANG Description: MPLS RSVP interface hello interval | f336463:c0:m22 |
def _get_hello_tolerance(self): | return self.__hello_tolerance<EOL> | Getter method for hello_tolerance, mapped from YANG variable /mpls_state/rsvp/interfaces/hello_tolerance (uint32)
YANG Description: MPLS RSVP interface hello tolerance | f336463:c0:m24 |
def _set_hello_tolerance(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.__hello_tolerance = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for hello_tolerance, mapped from YANG variable /mpls_state/rsvp/interfaces/hello_tolerance (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_hello_tolerance is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_hello_tolerance() directly.
YANG Description: MPLS RSVP interface hello tolerance | f336463:c0:m25 |
def _get_hello_status(self): | return self.__hello_status<EOL> | Getter method for hello_status, mapped from YANG variable /mpls_state/rsvp/interfaces/hello_status (feature-config-status)
YANG Description: 1 | f336463:c0:m27 |
def _set_hello_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=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.__hello_status = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for hello_status, mapped from YANG variable /mpls_state/rsvp/interfaces/hello_status (feature-config-status)
If this variable is read-only (config: false) in the
source YANG file, then _set_hello_status is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_hello_status() directly.
YANG Description: 1 | f336463:c0:m28 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.