signature stringlengths 8 3.44k | body stringlengths 0 1.41M | docstring stringlengths 1 122k | id stringlengths 5 17 |
|---|---|---|---|
def _get_targeted_peer(self): | return self.__targeted_peer<EOL> | Getter method for targeted_peer, mapped from YANG variable /mpls_state/ldp/targeted_peer (list)
YANG Description: LDP Targeted Peer | f335960:c0:m129 |
def _set_targeted_peer(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>",targeted_peer.targeted_peer, 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.__targeted_peer = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for targeted_peer, mapped from YANG variable /mpls_state/ldp/targeted_peer (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_targeted_peer is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_targeted_peer() directly.
YANG Description: LDP Targeted Peer | f335960:c0:m130 |
def _get_path(self): | return self.__path<EOL> | Getter method for path, mapped from YANG variable /mpls_state/ldp/path (list)
YANG Description: LDP Path information | f335960:c0:m132 |
def _set_path(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGListType("<STR_LIT>",path.path, yang_name="<STR_LIT:path>", rest_name="<STR_LIT:path>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT>', extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}), is_container='<STR_LIT:list>', yang_name="<STR_LIT:path>", rest_name="<STR_LIT:path>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:list>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__path = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for path, mapped from YANG variable /mpls_state/ldp/path (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_path is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_path() directly.
YANG Description: LDP Path information | f335960:c0:m133 |
def _get_ldp_neighbors(self): | return self.__ldp_neighbors<EOL> | Getter method for ldp_neighbors, mapped from YANG variable /mpls_state/ldp/ldp_neighbors (list)
YANG Description: LDP neighbor details | f335960:c0:m135 |
def _set_ldp_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>",ldp_neighbors.ldp_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.__ldp_neighbors = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ldp_neighbors, mapped from YANG variable /mpls_state/ldp/ldp_neighbors (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_ldp_neighbors is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ldp_neighbors() directly.
YANG Description: LDP neighbor details | f335960:c0:m136 |
def _get_ldp_session(self): | return self.__ldp_session<EOL> | Getter method for ldp_session, mapped from YANG variable /mpls_state/ldp/ldp_session (list) | f335960:c0:m138 |
def _set_ldp_session(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>",ldp_session.ldp_session, 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.__ldp_session = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ldp_session, mapped from YANG variable /mpls_state/ldp/ldp_session (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_ldp_session is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ldp_session() directly. | f335960:c0:m139 |
def _get_ldp_fec_prefix(self): | return self.__ldp_fec_prefix<EOL> | Getter method for ldp_fec_prefix, mapped from YANG variable /mpls_state/ldp/ldp_fec_prefix (list)
YANG Description: LDP Prefix FEC information | f335960:c0:m141 |
def _set_ldp_fec_prefix(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>",ldp_fec_prefix.ldp_fec_prefix, 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.__ldp_fec_prefix = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ldp_fec_prefix, mapped from YANG variable /mpls_state/ldp/ldp_fec_prefix (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_ldp_fec_prefix is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ldp_fec_prefix() directly.
YANG Description: LDP Prefix FEC information | f335960:c0:m142 |
def _get_ldp_fec_vc(self): | return self.__ldp_fec_vc<EOL> | Getter method for ldp_fec_vc, mapped from YANG variable /mpls_state/ldp/ldp_fec_vc (list)
YANG Description: LDP VC FEC information | f335960:c0:m144 |
def _set_ldp_fec_vc(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>",ldp_fec_vc.ldp_fec_vc, 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.__ldp_fec_vc = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ldp_fec_vc, mapped from YANG variable /mpls_state/ldp/ldp_fec_vc (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_ldp_fec_vc is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ldp_fec_vc() directly.
YANG Description: LDP VC FEC information | f335960:c0:m145 |
def _get_cspf_intf(self): | return self.__cspf_intf<EOL> | Getter method for cspf_intf, mapped from YANG variable /mpls_state/policy/cspf_intf (uint8)
YANG Description: CSPF Interface constraint | f335961:c0:m3 |
def _set_cspf_intf(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:8>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__cspf_intf = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for cspf_intf, mapped from YANG variable /mpls_state/policy/cspf_intf (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_cspf_intf is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_cspf_intf() directly.
YANG Description: CSPF Interface constraint | f335961:c0:m4 |
def _get_cspf_group_computation_mode(self): | return self.__cspf_group_computation_mode<EOL> | Getter method for cspf_group_computation_mode, mapped from YANG variable /mpls_state/policy/cspf_group_computation_mode (mpls-cspf-grp-comp-mode)
YANG Description: CSPF Group Computation Mode | f335961:c0:m6 |
def _set_cspf_group_computation_mode(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:0>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:4>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:3>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__cspf_group_computation_mode = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for cspf_group_computation_mode, mapped from YANG variable /mpls_state/policy/cspf_group_computation_mode (mpls-cspf-grp-comp-mode)
If this variable is read-only (config: false) in the
source YANG file, then _set_cspf_group_computation_mode is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_cspf_group_computation_mode() directly.
YANG Description: CSPF Group Computation Mode | f335961:c0:m7 |
def _get_cspf_comp_mode(self): | return self.__cspf_comp_mode<EOL> | Getter method for cspf_comp_mode, mapped from YANG variable /mpls_state/policy/cspf_comp_mode (uint32)
YANG Description: CSPF Computation Mode | f335961:c0:m9 |
def _set_cspf_comp_mode(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__cspf_comp_mode = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for cspf_comp_mode, mapped from YANG variable /mpls_state/policy/cspf_comp_mode (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_cspf_comp_mode is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_cspf_comp_mode() directly.
YANG Description: CSPF Computation Mode | f335961:c0:m10 |
def _get_cspf_comp_ignore_overload_bit(self): | return self.__cspf_comp_ignore_overload_bit<EOL> | Getter method for cspf_comp_ignore_overload_bit, mapped from YANG variable /mpls_state/policy/cspf_comp_ignore_overload_bit (uint8)
YANG Description: CSPF Computation Ignore Overload Bit | f335961:c0:m12 |
def _set_cspf_comp_ignore_overload_bit(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:8>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__cspf_comp_ignore_overload_bit = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for cspf_comp_ignore_overload_bit, mapped from YANG variable /mpls_state/policy/cspf_comp_ignore_overload_bit (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_cspf_comp_ignore_overload_bit is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_cspf_comp_ignore_overload_bit() directly.
YANG Description: CSPF Computation Ignore Overload Bit | f335961:c0:m13 |
def _get_implicit_commit_value(self): | return self.__implicit_commit_value<EOL> | Getter method for implicit_commit_value, mapped from YANG variable /mpls_state/policy/implicit_commit_value (uint32)
YANG Description: MPLS Implicit Commit value | f335961:c0:m15 |
def _set_implicit_commit_value(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__implicit_commit_value = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for implicit_commit_value, mapped from YANG variable /mpls_state/policy/implicit_commit_value (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_implicit_commit_value is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_implicit_commit_value() directly.
YANG Description: MPLS Implicit Commit value | f335961:c0:m16 |
def _get_qos_ttl_mode(self): | return self.__qos_ttl_mode<EOL> | Getter method for qos_ttl_mode, mapped from YANG variable /mpls_state/policy/qos_ttl_mode (qos-ttl-mode)
YANG Description: MPLS Qos TTL Mode | f335961:c0:m18 |
def _set_qos_ttl_mode(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:0>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT: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.__qos_ttl_mode = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for qos_ttl_mode, mapped from YANG variable /mpls_state/policy/qos_ttl_mode (qos-ttl-mode)
If this variable is read-only (config: false) in the
source YANG file, then _set_qos_ttl_mode is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_qos_ttl_mode() directly.
YANG Description: MPLS Qos TTL Mode | f335961:c0:m19 |
def _get_rtm_route_filter_enabled(self): | return self.__rtm_route_filter_enabled<EOL> | Getter method for rtm_route_filter_enabled, mapped from YANG variable /mpls_state/policy/rtm_route_filter_enabled (boolean)
YANG Description: RTM route filter enabled | f335961:c0:m21 |
def _set_rtm_route_filter_enabled(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__rtm_route_filter_enabled = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rtm_route_filter_enabled, mapped from YANG variable /mpls_state/policy/rtm_route_filter_enabled (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_rtm_route_filter_enabled is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rtm_route_filter_enabled() directly.
YANG Description: RTM route filter enabled | f335961:c0:m22 |
def _get_rtm_route_filter_all_ibgp_enabled(self): | return self.__rtm_route_filter_all_ibgp_enabled<EOL> | Getter method for rtm_route_filter_all_ibgp_enabled, mapped from YANG variable /mpls_state/policy/rtm_route_filter_all_ibgp_enabled (boolean)
YANG Description: RTM route filter all IBGP enabled | f335961:c0:m24 |
def _set_rtm_route_filter_all_ibgp_enabled(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__rtm_route_filter_all_ibgp_enabled = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rtm_route_filter_all_ibgp_enabled, mapped from YANG variable /mpls_state/policy/rtm_route_filter_all_ibgp_enabled (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_rtm_route_filter_all_ibgp_enabled is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rtm_route_filter_all_ibgp_enabled() directly.
YANG Description: RTM route filter all IBGP enabled | f335961:c0:m25 |
def _get_ingress_tnnl_actg(self): | return self.__ingress_tnnl_actg<EOL> | Getter method for ingress_tnnl_actg, mapped from YANG variable /mpls_state/policy/ingress_tnnl_actg (uint8)
YANG Description: MPLS Ingress Tunnel Accounting | f335961:c0:m27 |
def _set_ingress_tnnl_actg(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:8>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__ingress_tnnl_actg = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ingress_tnnl_actg, mapped from YANG variable /mpls_state/policy/ingress_tnnl_actg (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_ingress_tnnl_actg is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ingress_tnnl_actg() directly.
YANG Description: MPLS Ingress Tunnel Accounting | f335961:c0:m28 |
def _get_transit_session_actg(self): | return self.__transit_session_actg<EOL> | Getter method for transit_session_actg, mapped from YANG variable /mpls_state/policy/transit_session_actg (uint8)
YANG Description: MPLS Transit Session Accounting | f335961:c0:m30 |
def _set_transit_session_actg(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:8>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__transit_session_actg = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for transit_session_actg, mapped from YANG variable /mpls_state/policy/transit_session_actg (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_transit_session_actg is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_transit_session_actg() directly.
YANG Description: MPLS Transit Session Accounting | f335961:c0:m31 |
def _get_load_interval(self): | return self.__load_interval<EOL> | Getter method for load_interval, mapped from YANG variable /mpls_state/policy/load_interval (uint16)
YANG Description: MPLS Load Interval | f335961:c0:m33 |
def _set_load_interval(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']},int_size=<NUM_LIT:16>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__load_interval = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for load_interval, mapped from YANG variable /mpls_state/policy/load_interval (uint16)
If this variable is read-only (config: false) in the
source YANG file, then _set_load_interval is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_load_interval() directly.
YANG Description: MPLS Load Interval | f335961:c0:m34 |
def _get_te_policy_protocol(self): | return self.__te_policy_protocol<EOL> | Getter method for te_policy_protocol, mapped from YANG variable /mpls_state/policy/te_policy_protocol (te-protocol)
YANG Description: MPLS TE Protocol | f335961:c0:m36 |
def _set_te_policy_protocol(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:0>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__te_policy_protocol = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for te_policy_protocol, mapped from YANG variable /mpls_state/policy/te_policy_protocol (te-protocol)
If this variable is read-only (config: false) in the
source YANG file, then _set_te_policy_protocol is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_te_policy_protocol() directly.
YANG Description: MPLS TE Protocol | f335961:c0:m37 |
def _get_te_policy_flags(self): | return self.__te_policy_flags<EOL> | Getter method for te_policy_flags, mapped from YANG variable /mpls_state/policy/te_policy_flags (uint16)
YANG Description: MPLS TE policy flags | f335961:c0:m39 |
def _set_te_policy_flags(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']},int_size=<NUM_LIT:16>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__te_policy_flags = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for te_policy_flags, mapped from YANG variable /mpls_state/policy/te_policy_flags (uint16)
If this variable is read-only (config: false) in the
source YANG file, then _set_te_policy_flags is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_te_policy_flags() directly.
YANG Description: MPLS TE policy flags | f335961:c0:m40 |
def _get_te_policy_area(self): | return self.__te_policy_area<EOL> | Getter method for te_policy_area, mapped from YANG variable /mpls_state/policy/te_policy_area (uint32)
YANG Description: MPLS TE area | f335961:c0:m42 |
def _set_te_policy_area(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__te_policy_area = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for te_policy_area, mapped from YANG variable /mpls_state/policy/te_policy_area (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_te_policy_area is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_te_policy_area() directly.
YANG Description: MPLS TE area | f335961:c0:m43 |
def _get_handle_isis_nbr_down(self): | return self.__handle_isis_nbr_down<EOL> | Getter method for handle_isis_nbr_down, mapped from YANG variable /mpls_state/policy/handle_isis_nbr_down (uint8)
YANG Description: MPLS Handle ISIS neighbor down | f335961:c0:m45 |
def _set_handle_isis_nbr_down(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:8>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__handle_isis_nbr_down = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for handle_isis_nbr_down, mapped from YANG variable /mpls_state/policy/handle_isis_nbr_down (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_handle_isis_nbr_down is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_handle_isis_nbr_down() directly.
YANG Description: MPLS Handle ISIS neighbor down | f335961:c0:m46 |
def _get_handle_ospf_nbr_down(self): | return self.__handle_ospf_nbr_down<EOL> | Getter method for handle_ospf_nbr_down, mapped from YANG variable /mpls_state/policy/handle_ospf_nbr_down (uint8)
YANG Description: MPLS Handle OSPF neighbor down | f335961:c0:m48 |
def _set_handle_ospf_nbr_down(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:8>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__handle_ospf_nbr_down = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for handle_ospf_nbr_down, mapped from YANG variable /mpls_state/policy/handle_ospf_nbr_down (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_handle_ospf_nbr_down is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_handle_ospf_nbr_down() directly.
YANG Description: MPLS Handle OSPF neighbor down | f335961:c0:m49 |
def _get_max_lsp_retries(self): | return self.__max_lsp_retries<EOL> | Getter method for max_lsp_retries, mapped from YANG variable /mpls_state/policy/max_lsp_retries (uint16)
YANG Description: MPLS max lsp retries | f335961:c0:m51 |
def _set_max_lsp_retries(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']},int_size=<NUM_LIT:16>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__max_lsp_retries = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for max_lsp_retries, mapped from YANG variable /mpls_state/policy/max_lsp_retries (uint16)
If this variable is read-only (config: false) in the
source YANG file, then _set_max_lsp_retries is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_max_lsp_retries() directly.
YANG Description: MPLS max lsp retries | f335961:c0:m52 |
def _get_fast_retry_on(self): | return self.__fast_retry_on<EOL> | Getter method for fast_retry_on, mapped from YANG variable /mpls_state/policy/fast_retry_on (uint8)
YANG Description: MPLS fast retry on | f335961:c0:m54 |
def _set_fast_retry_on(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:8>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__fast_retry_on = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for fast_retry_on, mapped from YANG variable /mpls_state/policy/fast_retry_on (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_fast_retry_on is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_fast_retry_on() directly.
YANG Description: MPLS fast retry on | f335961:c0:m55 |
def _get_lsp_retry_interval(self): | return self.__lsp_retry_interval<EOL> | Getter method for lsp_retry_interval, mapped from YANG variable /mpls_state/policy/lsp_retry_interval (uint16)
YANG Description: MPLS lsp retry interval | f335961:c0:m57 |
def _set_lsp_retry_interval(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']},int_size=<NUM_LIT:16>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__lsp_retry_interval = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for lsp_retry_interval, mapped from YANG variable /mpls_state/policy/lsp_retry_interval (uint16)
If this variable is read-only (config: false) in the
source YANG file, then _set_lsp_retry_interval is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lsp_retry_interval() directly.
YANG Description: MPLS lsp retry interval | f335961:c0:m58 |
def _get_frr_backup_retry_interval(self): | return self.__frr_backup_retry_interval<EOL> | Getter method for frr_backup_retry_interval, mapped from YANG variable /mpls_state/policy/frr_backup_retry_interval (uint32)
YANG Description: MPLS FRR backup retry interval | f335961:c0:m60 |
def _set_frr_backup_retry_interval(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__frr_backup_retry_interval = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for frr_backup_retry_interval, mapped from YANG variable /mpls_state/policy/frr_backup_retry_interval (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_frr_backup_retry_interval is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_frr_backup_retry_interval() directly.
YANG Description: MPLS FRR backup retry interval | f335961:c0:m61 |
def _get_auto_bandwidth_enabled(self): | return self.__auto_bandwidth_enabled<EOL> | Getter method for auto_bandwidth_enabled, mapped from YANG variable /mpls_state/policy/auto_bandwidth_enabled (uint8)
YANG Description: MPLS Autobw | f335961:c0:m63 |
def _set_auto_bandwidth_enabled(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:8>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__auto_bandwidth_enabled = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for auto_bandwidth_enabled, mapped from YANG variable /mpls_state/policy/auto_bandwidth_enabled (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_auto_bandwidth_enabled is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_auto_bandwidth_enabled() directly.
YANG Description: MPLS Autobw | f335961:c0:m64 |
def _get_autobw_sample_interval(self): | return self.__autobw_sample_interval<EOL> | Getter method for autobw_sample_interval, mapped from YANG variable /mpls_state/policy/autobw_sample_interval (uint32)
YANG Description: MPLS Autobw sample interval | f335961:c0:m66 |
def _set_autobw_sample_interval(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__autobw_sample_interval = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for autobw_sample_interval, mapped from YANG variable /mpls_state/policy/autobw_sample_interval (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_autobw_sample_interval is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_autobw_sample_interval() directly.
YANG Description: MPLS Autobw sample interval | f335961:c0:m67 |
def _get_autobw_num_sample_record(self): | return self.__autobw_num_sample_record<EOL> | Getter method for autobw_num_sample_record, mapped from YANG variable /mpls_state/policy/autobw_num_sample_record (uint32)
YANG Description: MPLS Autobw num sample record | f335961:c0:m69 |
def _set_autobw_num_sample_record(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__autobw_num_sample_record = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for autobw_num_sample_record, mapped from YANG variable /mpls_state/policy/autobw_num_sample_record (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_autobw_num_sample_record is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_autobw_num_sample_record() directly.
YANG Description: MPLS Autobw num sample record | f335961:c0:m70 |
def _get_soft_preempt_cleanup_timer(self): | return self.__soft_preempt_cleanup_timer<EOL> | Getter method for soft_preempt_cleanup_timer, mapped from YANG variable /mpls_state/policy/soft_preempt_cleanup_timer (uint16)
YANG Description: MPLS Soft Preempt cleanup timer | f335961:c0:m72 |
def _set_soft_preempt_cleanup_timer(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']},int_size=<NUM_LIT:16>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__soft_preempt_cleanup_timer = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for soft_preempt_cleanup_timer, mapped from YANG variable /mpls_state/policy/soft_preempt_cleanup_timer (uint16)
If this variable is read-only (config: false) in the
source YANG file, then _set_soft_preempt_cleanup_timer is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_soft_preempt_cleanup_timer() directly.
YANG Description: MPLS Soft Preempt cleanup timer | f335961:c0:m73 |
def _get_rsvp_periodic_flooding_timer(self): | return self.__rsvp_periodic_flooding_timer<EOL> | Getter method for rsvp_periodic_flooding_timer, mapped from YANG variable /mpls_state/policy/rsvp_periodic_flooding_timer (uint16)
YANG Description: MPLS RSVP periodic flooding timer | f335961:c0:m75 |
def _set_rsvp_periodic_flooding_timer(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']},int_size=<NUM_LIT:16>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__rsvp_periodic_flooding_timer = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rsvp_periodic_flooding_timer, mapped from YANG variable /mpls_state/policy/rsvp_periodic_flooding_timer (uint16)
If this variable is read-only (config: false) in the
source YANG file, then _set_rsvp_periodic_flooding_timer is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rsvp_periodic_flooding_timer() directly.
YANG Description: MPLS RSVP periodic flooding timer | f335961:c0:m76 |
def _get_switchover_activation_delay(self): | return self.__switchover_activation_delay<EOL> | Getter method for switchover_activation_delay, mapped from YANG variable /mpls_state/policy/switchover_activation_delay (uint32)
YANG Description: LSP new instance activation delay | f335961:c0:m78 |
def _set_switchover_activation_delay(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.__switchover_activation_delay = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for switchover_activation_delay, mapped from YANG variable /mpls_state/policy/switchover_activation_delay (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_switchover_activation_delay is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_switchover_activation_delay() directly.
YANG Description: LSP new instance activation delay | f335961:c0:m79 |
def _get_switchover_hold_tear_delay(self): | return self.__switchover_hold_tear_delay<EOL> | Getter method for switchover_hold_tear_delay, mapped from YANG variable /mpls_state/policy/switchover_hold_tear_delay (uint32)
YANG Description: LSP old instance tear down delay | f335961:c0:m81 |
def _set_switchover_hold_tear_delay(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.__switchover_hold_tear_delay = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for switchover_hold_tear_delay, mapped from YANG variable /mpls_state/policy/switchover_hold_tear_delay (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_switchover_hold_tear_delay is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_switchover_hold_tear_delay() directly.
YANG Description: LSP old instance tear down delay | f335961:c0:m82 |
def _get_admin_groups(self): | return self.__admin_groups<EOL> | Getter method for admin_groups, mapped from YANG variable /mpls_state/policy/admin_groups (list)
YANG Description: MPLS Admin Group Entry | f335961:c0:m84 |
def _set_admin_groups(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGListType("<STR_LIT:name>",admin_groups.admin_groups, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT:name>', extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}), is_container='<STR_LIT:list>', yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:list>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__admin_groups = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for admin_groups, mapped from YANG variable /mpls_state/policy/admin_groups (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_admin_groups is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_admin_groups() directly.
YANG Description: MPLS Admin Group Entry | f335961:c0:m85 |
def _get_rsvp_flooding_thresholds(self): | return self.__rsvp_flooding_thresholds<EOL> | Getter method for rsvp_flooding_thresholds, mapped from YANG variable /mpls_state/policy/rsvp_flooding_thresholds (list)
YANG Description: RSVP Flooding Threshold | f335961:c0:m87 |
def _set_rsvp_flooding_thresholds(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGListType("<STR_LIT>",rsvp_flooding_thresholds.rsvp_flooding_thresholds, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT>', extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}), is_container='<STR_LIT:list>', yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:list>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__rsvp_flooding_thresholds = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rsvp_flooding_thresholds, mapped from YANG variable /mpls_state/policy/rsvp_flooding_thresholds (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_rsvp_flooding_thresholds is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rsvp_flooding_thresholds() directly.
YANG Description: RSVP Flooding Threshold | f335961:c0:m88 |
def _get_ip_address(self): | return self.__ip_address<EOL> | Getter method for ip_address, mapped from YANG variable /mpls_state/rsvp/igp_sync/link/ip_address (inet:ipv4-address)
YANG Description: Link ip address | f335962:c0:m3 |
def _set_ip_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.__ip_address = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ip_address, mapped from YANG variable /mpls_state/rsvp/igp_sync/link/ip_address (inet:ipv4-address)
If this variable is read-only (config: false) in the
source YANG file, then _set_ip_address is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ip_address() directly.
YANG Description: Link ip address | f335962:c0:m4 |
def _get_nbr_ip_address(self): | return self.__nbr_ip_address<EOL> | Getter method for nbr_ip_address, mapped from YANG variable /mpls_state/rsvp/igp_sync/link/nbr_ip_address (inet:ipv4-address)
YANG Description: Link remote end neighbor address | f335962:c0:m6 |
def _set_nbr_ip_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.__nbr_ip_address = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for nbr_ip_address, mapped from YANG variable /mpls_state/rsvp/igp_sync/link/nbr_ip_address (inet:ipv4-address)
If this variable is read-only (config: false) in the
source YANG file, then _set_nbr_ip_address is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_nbr_ip_address() directly.
YANG Description: Link remote end neighbor address | f335962:c0:m7 |
def _get_remote_ip(self): | return self.__remote_ip<EOL> | Getter method for remote_ip, mapped from YANG variable /mpls_state/rsvp/igp_sync/link/remote_ip (inet:ipv4-address)
YANG Description: Link remote end Ip address | f335962:c0:m9 |
def _set_remote_ip(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>'}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__remote_ip = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for remote_ip, mapped from YANG variable /mpls_state/rsvp/igp_sync/link/remote_ip (inet:ipv4-address)
If this variable is read-only (config: false) in the
source YANG file, then _set_remote_ip is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_remote_ip() directly.
YANG Description: Link remote end Ip address | f335962:c0:m10 |
def _get_lsp_count(self): | return self.__lsp_count<EOL> | Getter method for lsp_count, mapped from YANG variable /mpls_state/rsvp/igp_sync/link/lsp_count (uint32)
YANG Description: Number of LSPs using the link | f335962:c0:m12 |
def _set_lsp_count(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_count = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for lsp_count, mapped from YANG variable /mpls_state/rsvp/igp_sync/link/lsp_count (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_lsp_count is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lsp_count() directly.
YANG Description: Number of LSPs using the link | f335962:c0:m13 |
def _get_lsp(self): | return self.__lsp<EOL> | Getter method for lsp, mapped from YANG variable /mpls_state/rsvp/igp_sync/link/lsp (list) | f335962:c0:m15 |
def _set_lsp(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGListType("<STR_LIT>",lsp.lsp, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT>', extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>'}}), 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.__lsp = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for lsp, mapped from YANG variable /mpls_state/rsvp/igp_sync/link/lsp (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_lsp is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lsp() directly. | f335962:c0:m16 |
def _get_lsp_name(self): | return self.__lsp_name<EOL> | Getter method for lsp_name, mapped from YANG variable /mpls_state/rsvp/igp_sync/link/lsp/lsp_name (string)
YANG Description: LSP name | f335963:c0:m3 |
def _set_lsp_name(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__lsp_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for lsp_name, mapped from YANG variable /mpls_state/rsvp/igp_sync/link/lsp/lsp_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_lsp_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lsp_name() directly.
YANG Description: LSP name | f335963:c0:m4 |
def _get_lsp_instance_id(self): | return self.__lsp_instance_id<EOL> | Getter method for lsp_instance_id, mapped from YANG variable /mpls_state/rsvp/igp_sync/link/lsp/lsp_instance_id (uint32)
YANG Description: Instance id of the lsp instance | f335963:c0:m6 |
def _set_lsp_instance_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.__lsp_instance_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for lsp_instance_id, mapped from YANG variable /mpls_state/rsvp/igp_sync/link/lsp/lsp_instance_id (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_lsp_instance_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lsp_instance_id() directly.
YANG Description: Instance id of the lsp instance | f335963:c0:m7 |
def _get_path_name(self): | return self.__path_name<EOL> | Getter method for path_name, mapped from YANG variable /mpls_state/rsvp/igp_sync/link/lsp/path_name (string)
YANG Description: LSP Path name | f335963:c0:m9 |
def _set_path_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.__path_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for path_name, mapped from YANG variable /mpls_state/rsvp/igp_sync/link/lsp/path_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_path_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_path_name() directly.
YANG Description: LSP Path name | f335963:c0:m10 |
def _get_cspf_enabled(self): | return self.__cspf_enabled<EOL> | Getter method for cspf_enabled, mapped from YANG variable /mpls_state/rsvp/igp_sync/link/lsp/cspf_enabled (boolean)
YANG Description: CSPF enabled for LSP | f335963:c0:m12 |
def _set_cspf_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.__cspf_enabled = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for cspf_enabled, mapped from YANG variable /mpls_state/rsvp/igp_sync/link/lsp/cspf_enabled (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_cspf_enabled is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_cspf_enabled() directly.
YANG Description: CSPF enabled for LSP | f335963:c0:m13 |
def _get_rro_enabled(self): | return self.__rro_enabled<EOL> | Getter method for rro_enabled, mapped from YANG variable /mpls_state/rsvp/igp_sync/link/lsp/rro_enabled (boolean)
YANG Description: RRO enabled for LSP | f335963:c0:m15 |
def _set_rro_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.__rro_enabled = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rro_enabled, mapped from YANG variable /mpls_state/rsvp/igp_sync/link/lsp/rro_enabled (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_rro_enabled is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rro_enabled() directly.
YANG Description: RRO enabled for LSP | f335963:c0:m16 |
def _get_frr_enabled(self): | return self.__frr_enabled<EOL> | Getter method for frr_enabled, mapped from YANG variable /mpls_state/rsvp/igp_sync/link/lsp/frr_enabled (boolean)
YANG Description: FRR enabled for LSP | f335963:c0:m18 |
def _set_frr_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.__frr_enabled = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for frr_enabled, mapped from YANG variable /mpls_state/rsvp/igp_sync/link/lsp/frr_enabled (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_frr_enabled is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_frr_enabled() directly.
YANG Description: FRR enabled for LSP | f335963:c0:m19 |
def _get_nbr_down_enabled(self): | return self.__nbr_down_enabled<EOL> | Getter method for nbr_down_enabled, mapped from YANG variable /mpls_state/rsvp/igp_sync/link/lsp/nbr_down_enabled (boolean)
YANG Description: LSP Neighbour down is enabled | f335963:c0:m21 |
def _set_nbr_down_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.__nbr_down_enabled = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for nbr_down_enabled, mapped from YANG variable /mpls_state/rsvp/igp_sync/link/lsp/nbr_down_enabled (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_nbr_down_enabled is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_nbr_down_enabled() directly.
YANG Description: LSP Neighbour down is enabled | f335963:c0:m22 |
def _get_link_count(self): | return self.__link_count<EOL> | Getter method for link_count, mapped from YANG variable /mpls_state/rsvp/igp_sync/link/lsp/link_count (uint32)
YANG Description: Total links used by the LSP | f335963:c0:m24 |
def _set_link_count(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.__link_count = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for link_count, mapped from YANG variable /mpls_state/rsvp/igp_sync/link/lsp/link_count (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_link_count is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_link_count() directly.
YANG Description: Total links used by the LSP | f335963:c0:m25 |
def _get_nbr_down_inprogress(self): | return self.__nbr_down_inprogress<EOL> | Getter method for nbr_down_inprogress, mapped from YANG variable /mpls_state/rsvp/igp_sync/link/lsp/nbr_down_inprogress (boolean)
YANG Description: Neighbor down processing is in progress | f335963:c0:m27 |
def _set_nbr_down_inprogress(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.__nbr_down_inprogress = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for nbr_down_inprogress, mapped from YANG variable /mpls_state/rsvp/igp_sync/link/lsp/nbr_down_inprogress (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_nbr_down_inprogress is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_nbr_down_inprogress() directly.
YANG Description: Neighbor down processing is in progress | f335963:c0:m28 |
def _get_cspf_hop_count(self): | return self.__cspf_hop_count<EOL> | Getter method for cspf_hop_count, mapped from YANG variable /mpls_state/rsvp/igp_sync/link/lsp/cspf_hop_count (uint32)
YANG Description: CSPF hop count | f335963:c0:m30 |
def _set_cspf_hop_count(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__cspf_hop_count = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for cspf_hop_count, mapped from YANG variable /mpls_state/rsvp/igp_sync/link/lsp/cspf_hop_count (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_cspf_hop_count is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_cspf_hop_count() directly.
YANG Description: CSPF hop count | f335963:c0:m31 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.