signature stringlengths 8 3.44k | body stringlengths 0 1.41M | docstring stringlengths 1 122k | id stringlengths 5 17 |
|---|---|---|---|
def _get_rro_hop_count(self): | return self.__rro_hop_count<EOL> | Getter method for rro_hop_count, mapped from YANG variable /mpls_state/rsvp/igp_sync/link/lsp/rro_hop_count (uint32)
YANG Description: RRO hop rout | f335963:c0:m33 |
def _set_rro_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.__rro_hop_count = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rro_hop_count, mapped from YANG variable /mpls_state/rsvp/igp_sync/link/lsp/rro_hop_count (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_rro_hop_count is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rro_hop_count() directly.
YANG Description: RRO hop rout | f335963:c0:m34 |
def _get_hops(self): | return self.__hops<EOL> | Getter method for hops, mapped from YANG variable /mpls_state/rsvp/igp_sync/link/lsp/hops (list)
YANG Description: MPLS Rsvp IGP Synchronization Hop information | f335963:c0:m36 |
def _set_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>",hops.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>', 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.__hops = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for hops, mapped from YANG variable /mpls_state/rsvp/igp_sync/link/lsp/hops (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_hops is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_hops() directly.
YANG Description: MPLS Rsvp IGP Synchronization Hop information | f335963:c0:m37 |
def _get_index(self): | return self.__index<EOL> | Getter method for index, mapped from YANG variable /mpls_state/rsvp/igp_sync/link/lsp/hops/index (uint32)
YANG Description: Hop index | f335964:c0:m3 |
def _set_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:index>", rest_name="<STR_LIT:index>", 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.__index = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for index, mapped from YANG variable /mpls_state/rsvp/igp_sync/link/lsp/hops/index (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_index is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_index() directly.
YANG Description: Hop index | f335964:c0:m4 |
def _get_hop_type(self): | return self.__hop_type<EOL> | Getter method for hop_type, mapped from YANG variable /mpls_state/rsvp/igp_sync/link/lsp/hops/hop_type (igp-sync-hop-type)
YANG Description: Hop type | f335964:c0:m6 |
def _set_hop_type(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_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:3>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}},), 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_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for hop_type, mapped from YANG variable /mpls_state/rsvp/igp_sync/link/lsp/hops/hop_type (igp-sync-hop-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_hop_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_hop_type() directly.
YANG Description: Hop type | f335964:c0:m7 |
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/lsp/hops/ip_address (inet:ipv4-address)
YANG Description: Hop IPv4 address | f335964:c0:m9 |
def _set_ip_address(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>'}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__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/lsp/hops/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: Hop IPv4 address | f335964:c0:m10 |
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/lsp/hops/nbr_ip_address (inet:ipv4-address)
YANG Description: Hop remote neighbor IPv4 address | f335964:c0:m12 |
def _set_nbr_ip_address(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>'}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__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/lsp/hops/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: Hop remote neighbor IPv4 address | f335964:c0:m13 |
def _get_isis_nbr_down_enabled(self): | return self.__isis_nbr_down_enabled<EOL> | Getter method for isis_nbr_down_enabled, mapped from YANG variable /mpls_state/rsvp/igp_sync/isis_nbr_down_enabled (boolean)
YANG Description: ISIS neighbour down enabled | f335965:c0:m3 |
def _set_isis_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.__isis_nbr_down_enabled = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for isis_nbr_down_enabled, mapped from YANG variable /mpls_state/rsvp/igp_sync/isis_nbr_down_enabled (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_isis_nbr_down_enabled is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_isis_nbr_down_enabled() directly.
YANG Description: ISIS neighbour down enabled | f335965:c0:m4 |
def _get_ospf_nbr_down_enabled(self): | return self.__ospf_nbr_down_enabled<EOL> | Getter method for ospf_nbr_down_enabled, mapped from YANG variable /mpls_state/rsvp/igp_sync/ospf_nbr_down_enabled (boolean)
YANG Description: OSPF neighbour down enabled | f335965:c0:m6 |
def _set_ospf_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.__ospf_nbr_down_enabled = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ospf_nbr_down_enabled, mapped from YANG variable /mpls_state/rsvp/igp_sync/ospf_nbr_down_enabled (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_ospf_nbr_down_enabled is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ospf_nbr_down_enabled() directly.
YANG Description: OSPF neighbour down enabled | f335965:c0:m7 |
def _get_link(self): | return self.__link<EOL> | Getter method for link, mapped from YANG variable /mpls_state/rsvp/igp_sync/link (list)
YANG Description: MPLS Rsvp IGP Synchronization Link information | f335965:c0:m9 |
def _set_link(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>",link.link, 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.__link = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for link, mapped from YANG variable /mpls_state/rsvp/igp_sync/link (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_link is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_link() directly.
YANG Description: MPLS Rsvp IGP Synchronization Link information | f335965:c0:m10 |
def _get_lsp(self): | return self.__lsp<EOL> | Getter method for lsp, mapped from YANG variable /mpls_state/rsvp/igp_sync/lsp (list) | f335965:c0:m12 |
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/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. | f335965:c0:m13 |
def _get_lsp_name(self): | return self.__lsp_name<EOL> | Getter method for lsp_name, mapped from YANG variable /mpls_state/rsvp/igp_sync/lsp/lsp_name (string)
YANG Description: LSP name | f335966: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/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 | f335966: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/lsp/lsp_instance_id (uint32)
YANG Description: Instance id of the lsp instance | f335966: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/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 | f335966: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/lsp/path_name (string)
YANG Description: LSP Path name | f335966: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/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 | f335966: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/lsp/cspf_enabled (boolean)
YANG Description: CSPF enabled for LSP | f335966: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/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 | f335966: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/lsp/rro_enabled (boolean)
YANG Description: RRO enabled for LSP | f335966: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/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 | f335966: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/lsp/frr_enabled (boolean)
YANG Description: FRR enabled for LSP | f335966: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/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 | f335966: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/lsp/nbr_down_enabled (boolean)
YANG Description: LSP Neighbour down is enabled | f335966: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/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 | f335966: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/lsp/link_count (uint32)
YANG Description: Total links used by the LSP | f335966: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/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 | f335966: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/lsp/nbr_down_inprogress (boolean)
YANG Description: Neighbor down processing is in progress | f335966: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/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 | f335966: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/lsp/cspf_hop_count (uint32)
YANG Description: CSPF hop count | f335966: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/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 | f335966:c0:m31 |
def _get_rro_hop_count(self): | return self.__rro_hop_count<EOL> | Getter method for rro_hop_count, mapped from YANG variable /mpls_state/rsvp/igp_sync/lsp/rro_hop_count (uint32)
YANG Description: RRO hop rout | f335966:c0:m33 |
def _set_rro_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.__rro_hop_count = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rro_hop_count, mapped from YANG variable /mpls_state/rsvp/igp_sync/lsp/rro_hop_count (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_rro_hop_count is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rro_hop_count() directly.
YANG Description: RRO hop rout | f335966:c0:m34 |
def _get_hops(self): | return self.__hops<EOL> | Getter method for hops, mapped from YANG variable /mpls_state/rsvp/igp_sync/lsp/hops (list)
YANG Description: MPLS Rsvp IGP Synchronization Hop information | f335966:c0:m36 |
def _set_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>",hops.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>', 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.__hops = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for hops, mapped from YANG variable /mpls_state/rsvp/igp_sync/lsp/hops (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_hops is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_hops() directly.
YANG Description: MPLS Rsvp IGP Synchronization Hop information | f335966:c0:m37 |
def _get_index(self): | return self.__index<EOL> | Getter method for index, mapped from YANG variable /mpls_state/rsvp/igp_sync/lsp/hops/index (uint32)
YANG Description: Hop index | f335967:c0:m3 |
def _set_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:index>", rest_name="<STR_LIT:index>", 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.__index = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for index, mapped from YANG variable /mpls_state/rsvp/igp_sync/lsp/hops/index (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_index is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_index() directly.
YANG Description: Hop index | f335967:c0:m4 |
def _get_hop_type(self): | return self.__hop_type<EOL> | Getter method for hop_type, mapped from YANG variable /mpls_state/rsvp/igp_sync/lsp/hops/hop_type (igp-sync-hop-type)
YANG Description: Hop type | f335967:c0:m6 |
def _set_hop_type(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_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:3>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}},), 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_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for hop_type, mapped from YANG variable /mpls_state/rsvp/igp_sync/lsp/hops/hop_type (igp-sync-hop-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_hop_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_hop_type() directly.
YANG Description: Hop type | f335967:c0:m7 |
def _get_ip_address(self): | return self.__ip_address<EOL> | Getter method for ip_address, mapped from YANG variable /mpls_state/rsvp/igp_sync/lsp/hops/ip_address (inet:ipv4-address)
YANG Description: Hop IPv4 address | f335967:c0:m9 |
def _set_ip_address(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>'}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__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/lsp/hops/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: Hop IPv4 address | f335967:c0:m10 |
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/lsp/hops/nbr_ip_address (inet:ipv4-address)
YANG Description: Hop remote neighbor IPv4 address | f335967:c0:m12 |
def _set_nbr_ip_address(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>'}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__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/lsp/hops/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: Hop remote neighbor IPv4 address | f335967:c0:m13 |
def _get_filter_change_update_delay(self): | return self.__filter_change_update_delay<EOL> | Getter method for filter_change_update_delay, mapped from YANG variable /hide_filter_change_update_delay_holder/filter_change_update_delay (list)
YANG Description: Change filter change update delay timer | f335968:c0:m3 |
def _set_filter_change_update_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=YANGListType("<STR_LIT>",filter_change_update_delay.filter_change_update_delay, 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:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None, 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:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=True)<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.__filter_change_update_delay = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for filter_change_update_delay, mapped from YANG variable /hide_filter_change_update_delay_holder/filter_change_update_delay (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_filter_change_update_delay is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_filter_change_update_delay() directly.
YANG Description: Change filter change update delay timer | f335968:c0:m4 |
def _get_lsp_xc_traps(self): | return self.__lsp_xc_traps<EOL> | Getter method for lsp_xc_traps, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/lsp_xc_traps (container) | f335969:c0:m3 |
def _set_lsp_xc_traps(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=lsp_xc_traps.lsp_xc_traps, 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:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<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_xc_traps = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for lsp_xc_traps, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/lsp_xc_traps (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_lsp_xc_traps is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lsp_xc_traps() directly. | f335969:c0:m4 |
def _get_policy(self): | return self.__policy<EOL> | Getter method for policy, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/policy (container) | f335969:c0:m6 |
def _set_policy(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=policy.policy, is_container='<STR_LIT>', presence=True, 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:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<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.__policy = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for policy, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/policy (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_policy is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_policy() directly. | f335969:c0:m7 |
def _get_rsvp(self): | return self.__rsvp<EOL> | Getter method for rsvp, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/rsvp (container) | f335969:c0:m9 |
def _set_rsvp(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=rsvp.rsvp, is_container='<STR_LIT>', presence=True, 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:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<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 = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rsvp, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/rsvp (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_rsvp is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rsvp() directly. | f335969:c0:m10 |
def _get_ldp(self): | return self.__ldp<EOL> | Getter method for ldp, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/ldp (container) | f335969:c0:m12 |
def _set_ldp(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=ldp.ldp, is_container='<STR_LIT>', presence=True, 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:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<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.__ldp = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ldp, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/ldp (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_ldp is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ldp() directly. | f335969:c0:m13 |
def _get_bfd(self): | return self.__bfd<EOL> | Getter method for bfd, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/bfd (container) | f335969:c0:m15 |
def _set_bfd(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=bfd.bfd, is_container='<STR_LIT>', presence=True, 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:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<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.__bfd = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for bfd, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/bfd (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_bfd is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_bfd() directly. | f335969:c0:m16 |
def _get_dynamic_bypass(self): | return self.__dynamic_bypass<EOL> | Getter method for dynamic_bypass, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/dynamic_bypass (container) | f335969:c0:m18 |
def _set_dynamic_bypass(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=dynamic_bypass.dynamic_bypass, is_container='<STR_LIT>', presence=True, 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:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<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.__dynamic_bypass = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for dynamic_bypass, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/dynamic_bypass (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_dynamic_bypass is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_dynamic_bypass() directly. | f335969:c0:m19 |
def _get_mpls_interface(self): | return self.__mpls_interface<EOL> | Getter method for mpls_interface, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/mpls_interface (list) | f335969:c0:m21 |
def _set_mpls_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=YANGListType("<STR_LIT>",mpls_interface.mpls_interface, 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:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': 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:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=True)<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.__mpls_interface = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mpls_interface, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/mpls_interface (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_mpls_interface is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mpls_interface() directly. | f335969:c0:m22 |
def _get_autobw_template(self): | return self.__autobw_template<EOL> | Getter method for autobw_template, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/autobw_template (list) | f335969:c0:m24 |
def _set_autobw_template(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>",autobw_template.autobw_template, 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:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': 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:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=True)<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.__autobw_template = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for autobw_template, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/autobw_template (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_autobw_template is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_autobw_template() directly. | f335969:c0:m25 |
def _get_autobw_threshold_table(self): | return self.__autobw_threshold_table<EOL> | Getter method for autobw_threshold_table, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/autobw_threshold_table (container) | f335969:c0:m27 |
def _set_autobw_threshold_table(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=autobw_threshold_table.autobw_threshold_table, is_container='<STR_LIT>', presence=True, 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:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<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_threshold_table = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for autobw_threshold_table, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/autobw_threshold_table (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_autobw_threshold_table is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_autobw_threshold_table() directly. | f335969:c0:m28 |
def _get_cspf_group(self): | return self.__cspf_group<EOL> | Getter method for cspf_group, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/cspf_group (list) | f335969:c0:m30 |
def _set_cspf_group(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_group.cspf_group, 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:info>': u'<STR_LIT>', u'<STR_LIT>': 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:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=True)<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_group = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for cspf_group, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/cspf_group (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_cspf_group is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_cspf_group() directly. | f335969:c0:m31 |
def _get_path(self): | return self.__path<EOL> | Getter method for path, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/path (list) | f335969:c0:m33 |
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:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>'}}), 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:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=True)<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_config/router/mpls/mpls_cmds_holder/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. | f335969:c0:m34 |
def _get_bypass_lsp(self): | return self.__bypass_lsp<EOL> | Getter method for bypass_lsp, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/bypass_lsp (list) | f335969:c0:m36 |
def _set_bypass_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>",bypass_lsp.bypass_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:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': 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:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=True)<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.__bypass_lsp = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for bypass_lsp, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/bypass_lsp (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_bypass_lsp is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_bypass_lsp() directly. | f335969:c0:m37 |
def _get_lsp(self): | return self.__lsp<EOL> | Getter method for lsp, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/lsp (list) | f335969:c0:m39 |
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:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': 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:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=True)<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_config/router/mpls/mpls_cmds_holder/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. | f335969:c0:m40 |
def _get_policy_admin_group(self): | return self.__policy_admin_group<EOL> | Getter method for policy_admin_group, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/policy/policy_admin_group (list) | f335970:c0:m3 |
def _set_policy_admin_group(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>",policy_admin_group.policy_admin_group, 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:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, 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:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=True)<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.__policy_admin_group = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for policy_admin_group, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/policy/policy_admin_group (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_policy_admin_group is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_policy_admin_group() directly. | f335970:c0:m4 |
def _get_backup_retry_time(self): | return self.__backup_retry_time<EOL> | Getter method for backup_retry_time, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/policy/backup_retry_time (uint32) | f335970:c0:m6 |
def _set_backup_retry_time(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), default=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>)(<NUM_LIT:30>), is_leaf=True, 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>': None, u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__backup_retry_time = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for backup_retry_time, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/policy/backup_retry_time (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_backup_retry_time is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_backup_retry_time() directly. | f335970:c0:m7 |
def _get_cspf_computation_mode(self): | return self.__cspf_computation_mode<EOL> | Getter method for cspf_computation_mode, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/policy/cspf_computation_mode (container) | f335970:c0:m9 |
def _set_cspf_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=cspf_computation_mode.cspf_computation_mode, 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:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<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_computation_mode = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for cspf_computation_mode, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/policy/cspf_computation_mode (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_cspf_computation_mode is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_cspf_computation_mode() directly. | f335970:c0:m10 |
def _get_cspf_group_computation(self): | return self.__cspf_group_computation<EOL> | Getter method for cspf_group_computation, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/policy/cspf_group_computation (container) | f335970:c0:m12 |
def _set_cspf_group_computation(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=cspf_group_computation.cspf_group_computation, 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:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<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 = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for cspf_group_computation, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/policy/cspf_group_computation (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_cspf_group_computation is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_cspf_group_computation() directly. | f335970:c0:m13 |
def _get_cspf_interface_constraint(self): | return self.__cspf_interface_constraint<EOL> | Getter method for cspf_interface_constraint, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/policy/cspf_interface_constraint (empty) | f335970:c0:m15 |
def _set_cspf_interface_constraint(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, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<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_interface_constraint = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for cspf_interface_constraint, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/policy/cspf_interface_constraint (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_cspf_interface_constraint is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_cspf_interface_constraint() directly. | f335970:c0:m16 |
def _get_handle_isis_neighbor_down(self): | return self.__handle_isis_neighbor_down<EOL> | Getter method for handle_isis_neighbor_down, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/policy/handle_isis_neighbor_down (empty) | f335970:c0:m18 |
def _set_handle_isis_neighbor_down(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<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_neighbor_down = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for handle_isis_neighbor_down, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/policy/handle_isis_neighbor_down (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_handle_isis_neighbor_down is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_handle_isis_neighbor_down() directly. | f335970:c0:m19 |
def _get_handle_ospf_neighbor_down(self): | return self.__handle_ospf_neighbor_down<EOL> | Getter method for handle_ospf_neighbor_down, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/policy/handle_ospf_neighbor_down (empty) | f335970:c0:m21 |
def _set_handle_ospf_neighbor_down(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<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_neighbor_down = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for handle_ospf_neighbor_down, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/policy/handle_ospf_neighbor_down (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_handle_ospf_neighbor_down is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_handle_ospf_neighbor_down() directly. | f335970:c0:m22 |
def _get_load_interval(self): | return self.__load_interval<EOL> | Getter method for load_interval, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/policy/load_interval (uint32) | f335970:c0:m24 |
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=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), default=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>)(<NUM_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, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<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_config/router/mpls/mpls_cmds_holder/policy/load_interval (uint32)
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. | f335970:c0:m25 |
def _get_retry_time(self): | return self.__retry_time<EOL> | Getter method for retry_time, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/policy/retry_time (uint32) | f335970:c0:m27 |
def _set_retry_time(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), default=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>)(<NUM_LIT:30>), is_leaf=True, 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>': None, u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<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.__retry_time = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for retry_time, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/policy/retry_time (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_retry_time is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_retry_time() directly. | f335970:c0:m28 |
def _get_retry_limit(self): | return self.__retry_limit<EOL> | Getter method for retry_limit, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/policy/retry_limit (uint32) | f335970:c0:m30 |
def _set_retry_limit(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=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>', u'<STR_LIT>']}), default=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>)(<NUM_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, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<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.__retry_limit = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for retry_limit, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/policy/retry_limit (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_retry_limit is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_retry_limit() directly. | f335970:c0:m31 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.