signature stringlengths 8 3.44k | body stringlengths 0 1.41M | docstring stringlengths 1 122k | id stringlengths 5 17 |
|---|---|---|---|
def _get_max_bandwidth(self): | return self.__max_bandwidth<EOL> | Getter method for max_bandwidth, mapped from YANG variable /mpls_state/interface/max_bandwidth (uint32)
YANG Description: Maximum bandwidth | f336386:c0:m48 |
def _set_max_bandwidth(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__max_bandwidth = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for max_bandwidth, mapped from YANG variable /mpls_state/interface/max_bandwidth (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_max_bandwidth is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_max_bandwidth() directly.
YANG Description: Maximum bandwidth | f336386:c0:m49 |
def _get_max_resv_bandwidth(self): | return self.__max_resv_bandwidth<EOL> | Getter method for max_resv_bandwidth, mapped from YANG variable /mpls_state/interface/max_resv_bandwidth (uint32)
YANG Description: Maximum reservable bandwidth | f336386:c0:m51 |
def _set_max_resv_bandwidth(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__max_resv_bandwidth = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for max_resv_bandwidth, mapped from YANG variable /mpls_state/interface/max_resv_bandwidth (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_max_resv_bandwidth is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_max_resv_bandwidth() directly.
YANG Description: Maximum reservable bandwidth | f336386:c0:m52 |
def _get_max_resv_bandwidth_percentage(self): | return self.__max_resv_bandwidth_percentage<EOL> | Getter method for max_resv_bandwidth_percentage, mapped from YANG variable /mpls_state/interface/max_resv_bandwidth_percentage (uint32)
YANG Description: Max reservable bandwidth percentage | f336386:c0:m54 |
def _set_max_resv_bandwidth_percentage(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.__max_resv_bandwidth_percentage = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for max_resv_bandwidth_percentage, mapped from YANG variable /mpls_state/interface/max_resv_bandwidth_percentage (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_max_resv_bandwidth_percentage is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_max_resv_bandwidth_percentage() directly.
YANG Description: Max reservable bandwidth percentage | f336386:c0:m55 |
def _get_resv_bandwidth(self): | return self.__resv_bandwidth<EOL> | Getter method for resv_bandwidth, mapped from YANG variable /mpls_state/interface/resv_bandwidth (uint32)
YANG Description: Reservable bandwidth on different priority levels | f336386:c0:m57 |
def _set_resv_bandwidth(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>)), is_leaf=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__resv_bandwidth = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for resv_bandwidth, mapped from YANG variable /mpls_state/interface/resv_bandwidth (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_resv_bandwidth is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_resv_bandwidth() directly.
YANG Description: Reservable bandwidth on different priority levels | f336386:c0:m58 |
def _get_advert_unreserved_bandwidth(self): | return self.__advert_unreserved_bandwidth<EOL> | Getter method for advert_unreserved_bandwidth, mapped from YANG variable /mpls_state/interface/advert_unreserved_bandwidth (uint32)
YANG Description: Advertised unreserved bandwidth on different priority levels | f336386:c0:m60 |
def _set_advert_unreserved_bandwidth(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>)), is_leaf=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__advert_unreserved_bandwidth = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for advert_unreserved_bandwidth, mapped from YANG variable /mpls_state/interface/advert_unreserved_bandwidth (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_advert_unreserved_bandwidth is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_advert_unreserved_bandwidth() directly.
YANG Description: Advertised unreserved bandwidth on different priority levels | f336386:c0:m61 |
def _get_under_provisioned_bandwidth(self): | return self.__under_provisioned_bandwidth<EOL> | Getter method for under_provisioned_bandwidth, mapped from YANG variable /mpls_state/interface/under_provisioned_bandwidth (uint32)
YANG Description: Under provisioned bandwidth (subject to soft preemption) on different priority levels | f336386:c0:m63 |
def _set_under_provisioned_bandwidth(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>)), is_leaf=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__under_provisioned_bandwidth = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for under_provisioned_bandwidth, mapped from YANG variable /mpls_state/interface/under_provisioned_bandwidth (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_under_provisioned_bandwidth is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_under_provisioned_bandwidth() directly.
YANG Description: Under provisioned bandwidth (subject to soft preemption) on different priority levels | f336386:c0:m64 |
def _get_mpls_ldp_database_us_fec_label(self): | return self.__mpls_ldp_database_us_fec_label<EOL> | Getter method for mpls_ldp_database_us_fec_label, mapped from YANG variable /mpls_state/ldp/ldp_database/mpls_ldp_database_upstream/mpls_ldp_database_us_fec_label (uint32)
YANG Description: mpls ldp database fec label | f336387:c0:m3 |
def _set_mpls_ldp_database_us_fec_label(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__mpls_ldp_database_us_fec_label = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mpls_ldp_database_us_fec_label, mapped from YANG variable /mpls_state/ldp/ldp_database/mpls_ldp_database_upstream/mpls_ldp_database_us_fec_label (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_mpls_ldp_database_us_fec_label is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mpls_ldp_database_us_fec_label() directly.
YANG Description: mpls ldp database fec label | f336387:c0:m4 |
def _get_mpls_ldp_database_us_fec_prefix(self): | return self.__mpls_ldp_database_us_fec_prefix<EOL> | Getter method for mpls_ldp_database_us_fec_prefix, mapped from YANG variable /mpls_state/ldp/ldp_database/mpls_ldp_database_upstream/mpls_ldp_database_us_fec_prefix (inet:ipv4-address)
YANG Description: mpls ldp database fec prefix | f336387:c0:m6 |
def _set_mpls_ldp_database_us_fec_prefix(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.__mpls_ldp_database_us_fec_prefix = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mpls_ldp_database_us_fec_prefix, mapped from YANG variable /mpls_state/ldp/ldp_database/mpls_ldp_database_upstream/mpls_ldp_database_us_fec_prefix (inet:ipv4-address)
If this variable is read-only (config: false) in the
source YANG file, then _set_mpls_ldp_database_us_fec_prefix is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mpls_ldp_database_us_fec_prefix() directly.
YANG Description: mpls ldp database fec prefix | f336387:c0:m7 |
def _get_mpls_ldp_database_us_fec_prefix_length(self): | return self.__mpls_ldp_database_us_fec_prefix_length<EOL> | Getter method for mpls_ldp_database_us_fec_prefix_length, mapped from YANG variable /mpls_state/ldp/ldp_database/mpls_ldp_database_upstream/mpls_ldp_database_us_fec_prefix_length (uint32)
YANG Description: mpls ldp database fec prefix length | f336387:c0:m9 |
def _set_mpls_ldp_database_us_fec_prefix_length(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.__mpls_ldp_database_us_fec_prefix_length = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mpls_ldp_database_us_fec_prefix_length, mapped from YANG variable /mpls_state/ldp/ldp_database/mpls_ldp_database_upstream/mpls_ldp_database_us_fec_prefix_length (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_mpls_ldp_database_us_fec_prefix_length is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mpls_ldp_database_us_fec_prefix_length() directly.
YANG Description: mpls ldp database fec prefix length | f336387:c0:m10 |
def _get_mpls_ldp_database_us_fec_type(self): | return self.__mpls_ldp_database_us_fec_type<EOL> | Getter method for mpls_ldp_database_us_fec_type, mapped from YANG variable /mpls_state/ldp/ldp_database/mpls_ldp_database_upstream/mpls_ldp_database_us_fec_type (uint32)
YANG Description: mpls ldp database fec type | f336387:c0:m12 |
def _set_mpls_ldp_database_us_fec_type(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=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.__mpls_ldp_database_us_fec_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mpls_ldp_database_us_fec_type, mapped from YANG variable /mpls_state/ldp/ldp_database/mpls_ldp_database_upstream/mpls_ldp_database_us_fec_type (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_mpls_ldp_database_us_fec_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mpls_ldp_database_us_fec_type() directly.
YANG Description: mpls ldp database fec type | f336387:c0:m13 |
def _get_mpls_ldp_database_us_fec_stale(self): | return self.__mpls_ldp_database_us_fec_stale<EOL> | Getter method for mpls_ldp_database_us_fec_stale, mapped from YANG variable /mpls_state/ldp/ldp_database/mpls_ldp_database_upstream/mpls_ldp_database_us_fec_stale (boolean)
YANG Description: mpls ldp database fec stale | f336387:c0:m15 |
def _set_mpls_ldp_database_us_fec_stale(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.__mpls_ldp_database_us_fec_stale = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mpls_ldp_database_us_fec_stale, mapped from YANG variable /mpls_state/ldp/ldp_database/mpls_ldp_database_upstream/mpls_ldp_database_us_fec_stale (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_mpls_ldp_database_us_fec_stale is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mpls_ldp_database_us_fec_stale() directly.
YANG Description: mpls ldp database fec stale | f336387:c0:m16 |
def _get_ldp_database_peer_ip(self): | return self.__ldp_database_peer_ip<EOL> | Getter method for ldp_database_peer_ip, mapped from YANG variable /mpls_state/ldp/ldp_database/ldp_database_peer_ip (inet:ipv4-address)
YANG Description: LDP Peer IP Address | f336388:c0:m3 |
def _set_ldp_database_peer_ip(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.__ldp_database_peer_ip = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ldp_database_peer_ip, mapped from YANG variable /mpls_state/ldp/ldp_database/ldp_database_peer_ip (inet:ipv4-address)
If this variable is read-only (config: false) in the
source YANG file, then _set_ldp_database_peer_ip is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ldp_database_peer_ip() directly.
YANG Description: LDP Peer IP Address | f336388:c0:m4 |
def _get_ldp_database_own_ip(self): | return self.__ldp_database_own_ip<EOL> | Getter method for ldp_database_own_ip, mapped from YANG variable /mpls_state/ldp/ldp_database/ldp_database_own_ip (inet:ipv4-address)
YANG Description: LDP Own IP Address | f336388:c0:m6 |
def _set_ldp_database_own_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.__ldp_database_own_ip = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ldp_database_own_ip, mapped from YANG variable /mpls_state/ldp/ldp_database/ldp_database_own_ip (inet:ipv4-address)
If this variable is read-only (config: false) in the
source YANG file, then _set_ldp_database_own_ip is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ldp_database_own_ip() directly.
YANG Description: LDP Own IP Address | f336388:c0:m7 |
def _get_mpls_ldp_database_downstream(self): | return self.__mpls_ldp_database_downstream<EOL> | Getter method for mpls_ldp_database_downstream, mapped from YANG variable /mpls_state/ldp/ldp_database/mpls_ldp_database_downstream (list)
YANG Description: ldp database downstream | f336388:c0:m9 |
def _set_mpls_ldp_database_downstream(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_ldp_database_downstream.mpls_ldp_database_downstream, 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.__mpls_ldp_database_downstream = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mpls_ldp_database_downstream, mapped from YANG variable /mpls_state/ldp/ldp_database/mpls_ldp_database_downstream (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_mpls_ldp_database_downstream is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mpls_ldp_database_downstream() directly.
YANG Description: ldp database downstream | f336388:c0:m10 |
def _get_mpls_ldp_database_upstream(self): | return self.__mpls_ldp_database_upstream<EOL> | Getter method for mpls_ldp_database_upstream, mapped from YANG variable /mpls_state/ldp/ldp_database/mpls_ldp_database_upstream (list)
YANG Description: ldp database upstream | f336388:c0:m12 |
def _set_mpls_ldp_database_upstream(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_ldp_database_upstream.mpls_ldp_database_upstream, 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.__mpls_ldp_database_upstream = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mpls_ldp_database_upstream, mapped from YANG variable /mpls_state/ldp/ldp_database/mpls_ldp_database_upstream (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_mpls_ldp_database_upstream is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mpls_ldp_database_upstream() directly.
YANG Description: ldp database upstream | f336388:c0:m13 |
def _get_mpls_ldp_database_ds_fec_label(self): | return self.__mpls_ldp_database_ds_fec_label<EOL> | Getter method for mpls_ldp_database_ds_fec_label, mapped from YANG variable /mpls_state/ldp/ldp_database/mpls_ldp_database_downstream/mpls_ldp_database_ds_fec_label (uint32)
YANG Description: mpls ldp database fec label | f336389:c0:m3 |
def _set_mpls_ldp_database_ds_fec_label(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__mpls_ldp_database_ds_fec_label = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mpls_ldp_database_ds_fec_label, mapped from YANG variable /mpls_state/ldp/ldp_database/mpls_ldp_database_downstream/mpls_ldp_database_ds_fec_label (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_mpls_ldp_database_ds_fec_label is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mpls_ldp_database_ds_fec_label() directly.
YANG Description: mpls ldp database fec label | f336389:c0:m4 |
def _get_mpls_ldp_database_ds_fec_prefix(self): | return self.__mpls_ldp_database_ds_fec_prefix<EOL> | Getter method for mpls_ldp_database_ds_fec_prefix, mapped from YANG variable /mpls_state/ldp/ldp_database/mpls_ldp_database_downstream/mpls_ldp_database_ds_fec_prefix (inet:ipv4-address)
YANG Description: mpls ldp database fec prefix | f336389:c0:m6 |
def _set_mpls_ldp_database_ds_fec_prefix(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.__mpls_ldp_database_ds_fec_prefix = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mpls_ldp_database_ds_fec_prefix, mapped from YANG variable /mpls_state/ldp/ldp_database/mpls_ldp_database_downstream/mpls_ldp_database_ds_fec_prefix (inet:ipv4-address)
If this variable is read-only (config: false) in the
source YANG file, then _set_mpls_ldp_database_ds_fec_prefix is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mpls_ldp_database_ds_fec_prefix() directly.
YANG Description: mpls ldp database fec prefix | f336389:c0:m7 |
def _get_mpls_ldp_database_ds_fec_prefix_length(self): | return self.__mpls_ldp_database_ds_fec_prefix_length<EOL> | Getter method for mpls_ldp_database_ds_fec_prefix_length, mapped from YANG variable /mpls_state/ldp/ldp_database/mpls_ldp_database_downstream/mpls_ldp_database_ds_fec_prefix_length (uint32)
YANG Description: mpls ldp database fec prefix length | f336389:c0:m9 |
def _set_mpls_ldp_database_ds_fec_prefix_length(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.__mpls_ldp_database_ds_fec_prefix_length = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mpls_ldp_database_ds_fec_prefix_length, mapped from YANG variable /mpls_state/ldp/ldp_database/mpls_ldp_database_downstream/mpls_ldp_database_ds_fec_prefix_length (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_mpls_ldp_database_ds_fec_prefix_length is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mpls_ldp_database_ds_fec_prefix_length() directly.
YANG Description: mpls ldp database fec prefix length | f336389:c0:m10 |
def _get_mpls_ldp_database_ds_fec_type(self): | return self.__mpls_ldp_database_ds_fec_type<EOL> | Getter method for mpls_ldp_database_ds_fec_type, mapped from YANG variable /mpls_state/ldp/ldp_database/mpls_ldp_database_downstream/mpls_ldp_database_ds_fec_type (uint32)
YANG Description: mpls ldp database fec type | f336389:c0:m12 |
def _set_mpls_ldp_database_ds_fec_type(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=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.__mpls_ldp_database_ds_fec_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mpls_ldp_database_ds_fec_type, mapped from YANG variable /mpls_state/ldp/ldp_database/mpls_ldp_database_downstream/mpls_ldp_database_ds_fec_type (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_mpls_ldp_database_ds_fec_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mpls_ldp_database_ds_fec_type() directly.
YANG Description: mpls ldp database fec type | f336389:c0:m13 |
def _get_mpls_ldp_database_ds_fec_state(self): | return self.__mpls_ldp_database_ds_fec_state<EOL> | Getter method for mpls_ldp_database_ds_fec_state, mapped from YANG variable /mpls_state/ldp/ldp_database/mpls_ldp_database_downstream/mpls_ldp_database_ds_fec_state (string)
YANG Description: mpls ldp database fec state | f336389:c0:m15 |
def _set_mpls_ldp_database_ds_fec_state(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.__mpls_ldp_database_ds_fec_state = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mpls_ldp_database_ds_fec_state, mapped from YANG variable /mpls_state/ldp/ldp_database/mpls_ldp_database_downstream/mpls_ldp_database_ds_fec_state (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_mpls_ldp_database_ds_fec_state is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mpls_ldp_database_ds_fec_state() directly.
YANG Description: mpls ldp database fec state | f336389:c0:m16 |
def _get_mpls_ldp_database_ds_fec_filtered(self): | return self.__mpls_ldp_database_ds_fec_filtered<EOL> | Getter method for mpls_ldp_database_ds_fec_filtered, mapped from YANG variable /mpls_state/ldp/ldp_database/mpls_ldp_database_downstream/mpls_ldp_database_ds_fec_filtered (boolean)
YANG Description: mpls ldp database fec filtered | f336389:c0:m18 |
def _set_mpls_ldp_database_ds_fec_filtered(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.__mpls_ldp_database_ds_fec_filtered = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mpls_ldp_database_ds_fec_filtered, mapped from YANG variable /mpls_state/ldp/ldp_database/mpls_ldp_database_downstream/mpls_ldp_database_ds_fec_filtered (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_mpls_ldp_database_ds_fec_filtered is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mpls_ldp_database_ds_fec_filtered() directly.
YANG Description: mpls ldp database fec filtered | f336389:c0:m19 |
def _get_mpls_ldp_database_ds_fec_stale(self): | return self.__mpls_ldp_database_ds_fec_stale<EOL> | Getter method for mpls_ldp_database_ds_fec_stale, mapped from YANG variable /mpls_state/ldp/ldp_database/mpls_ldp_database_downstream/mpls_ldp_database_ds_fec_stale (boolean)
YANG Description: mpls ldp database fec stale | f336389:c0:m21 |
def _set_mpls_ldp_database_ds_fec_stale(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.__mpls_ldp_database_ds_fec_stale = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mpls_ldp_database_ds_fec_stale, mapped from YANG variable /mpls_state/ldp/ldp_database/mpls_ldp_database_downstream/mpls_ldp_database_ds_fec_stale (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_mpls_ldp_database_ds_fec_stale is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mpls_ldp_database_ds_fec_stale() directly.
YANG Description: mpls ldp database fec stale | f336389:c0:m22 |
def _get_mpls_ldp_database_ds_fec_lwd(self): | return self.__mpls_ldp_database_ds_fec_lwd<EOL> | Getter method for mpls_ldp_database_ds_fec_lwd, mapped from YANG variable /mpls_state/ldp/ldp_database/mpls_ldp_database_downstream/mpls_ldp_database_ds_fec_lwd (boolean)
YANG Description: mpls ldp database fec lwd | f336389:c0:m24 |
def _set_mpls_ldp_database_ds_fec_lwd(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.__mpls_ldp_database_ds_fec_lwd = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mpls_ldp_database_ds_fec_lwd, mapped from YANG variable /mpls_state/ldp/ldp_database/mpls_ldp_database_downstream/mpls_ldp_database_ds_fec_lwd (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_mpls_ldp_database_ds_fec_lwd is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mpls_ldp_database_ds_fec_lwd() directly.
YANG Description: mpls ldp database fec lwd | f336389:c0:m25 |
def _get_protocol_stats(self): | return self.__protocol_stats<EOL> | Getter method for protocol_stats, mapped from YANG variable /mpls_state/ldp/ldp_session/session_ldp_stats/ldp_protocol_stats_instance_total/protocol_stats (list)
YANG Description: protocol stats rx/tx | f336390:c0:m3 |
def _set_protocol_stats(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>",protocol_stats.protocol_stats, 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.__protocol_stats = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for protocol_stats, mapped from YANG variable /mpls_state/ldp/ldp_session/session_ldp_stats/ldp_protocol_stats_instance_total/protocol_stats (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_protocol_stats is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_protocol_stats() directly.
YANG Description: protocol stats rx/tx | f336390:c0:m4 |
def _get_stat_type(self): | return self.__stat_type<EOL> | Getter method for stat_type, mapped from YANG variable /mpls_state/ldp/ldp_session/session_ldp_stats/ldp_protocol_stats_instance_total/protocol_stats/stat_type (uint32)
YANG Description: Stat Counts | f336391:c0:m3 |
def _set_stat_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=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.__stat_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for stat_type, mapped from YANG variable /mpls_state/ldp/ldp_session/session_ldp_stats/ldp_protocol_stats_instance_total/protocol_stats/stat_type (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_stat_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_stat_type() directly.
YANG Description: Stat Counts | f336391:c0:m4 |
def _get_rx_count(self): | return self.__rx_count<EOL> | Getter method for rx_count, mapped from YANG variable /mpls_state/ldp/ldp_session/session_ldp_stats/ldp_protocol_stats_instance_total/protocol_stats/rx_count (uint32)
YANG Description: Receive Count | f336391:c0:m6 |
def _set_rx_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.__rx_count = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rx_count, mapped from YANG variable /mpls_state/ldp/ldp_session/session_ldp_stats/ldp_protocol_stats_instance_total/protocol_stats/rx_count (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_rx_count is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rx_count() directly.
YANG Description: Receive Count | f336391:c0:m7 |
def _get_tx_count(self): | return self.__tx_count<EOL> | Getter method for tx_count, mapped from YANG variable /mpls_state/ldp/ldp_session/session_ldp_stats/ldp_protocol_stats_instance_total/protocol_stats/tx_count (uint32)
YANG Description: Transmit Count | f336391:c0:m9 |
def _set_tx_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.__tx_count = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for tx_count, mapped from YANG variable /mpls_state/ldp/ldp_session/session_ldp_stats/ldp_protocol_stats_instance_total/protocol_stats/tx_count (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_tx_count is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tx_count() directly.
YANG Description: Transmit Count | f336391:c0:m10 |
def _get_ldp_protocol_errors_instance_total(self): | return self.__ldp_protocol_errors_instance_total<EOL> | Getter method for ldp_protocol_errors_instance_total, mapped from YANG variable /mpls_state/ldp/ldp_session/session_ldp_stats/ldp_protocol_errors_instance_total (container) | f336392:c0:m3 |
def _set_ldp_protocol_errors_instance_total(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_protocol_errors_instance_total.ldp_protocol_errors_instance_total, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__ldp_protocol_errors_instance_total = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ldp_protocol_errors_instance_total, mapped from YANG variable /mpls_state/ldp/ldp_session/session_ldp_stats/ldp_protocol_errors_instance_total (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_ldp_protocol_errors_instance_total is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ldp_protocol_errors_instance_total() directly. | f336392:c0:m4 |
def _get_ldp_protocol_stats_instance_total(self): | return self.__ldp_protocol_stats_instance_total<EOL> | Getter method for ldp_protocol_stats_instance_total, mapped from YANG variable /mpls_state/ldp/ldp_session/session_ldp_stats/ldp_protocol_stats_instance_total (container) | f336392:c0:m6 |
def _set_ldp_protocol_stats_instance_total(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_protocol_stats_instance_total.ldp_protocol_stats_instance_total, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__ldp_protocol_stats_instance_total = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ldp_protocol_stats_instance_total, mapped from YANG variable /mpls_state/ldp/ldp_session/session_ldp_stats/ldp_protocol_stats_instance_total (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_ldp_protocol_stats_instance_total is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ldp_protocol_stats_instance_total() directly. | f336392:c0:m7 |
def _get_error_type(self): | return self.__error_type<EOL> | Getter method for error_type, mapped from YANG variable /mpls_state/ldp/ldp_session/session_ldp_stats/ldp_protocol_errors_instance_total/protocol_errors/error_type (uint32)
YANG Description: Error Counts | f336393:c0:m3 |
def _set_error_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=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.__error_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for error_type, mapped from YANG variable /mpls_state/ldp/ldp_session/session_ldp_stats/ldp_protocol_errors_instance_total/protocol_errors/error_type (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_error_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_error_type() directly.
YANG Description: Error Counts | f336393:c0:m4 |
def _get_count(self): | return self.__count<EOL> | Getter method for count, mapped from YANG variable /mpls_state/ldp/ldp_session/session_ldp_stats/ldp_protocol_errors_instance_total/protocol_errors/count (uint32)
YANG Description: count | f336393:c0:m6 |
def _set_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:count>", rest_name="<STR_LIT:count>", 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.__count = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for count, mapped from YANG variable /mpls_state/ldp/ldp_session/session_ldp_stats/ldp_protocol_errors_instance_total/protocol_errors/count (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_count is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_count() directly.
YANG Description: count | f336393:c0:m7 |
def _get_protocol_errors(self): | return self.__protocol_errors<EOL> | Getter method for protocol_errors, mapped from YANG variable /mpls_state/ldp/ldp_session/session_ldp_stats/ldp_protocol_errors_instance_total/protocol_errors (list)
YANG Description: protocol errors | f336394:c0:m3 |
def _set_protocol_errors(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>",protocol_errors.protocol_errors, 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.__protocol_errors = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for protocol_errors, mapped from YANG variable /mpls_state/ldp/ldp_session/session_ldp_stats/ldp_protocol_errors_instance_total/protocol_errors (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_protocol_errors is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_protocol_errors() directly.
YANG Description: protocol errors | f336394:c0:m4 |
def _get_neighbor_ldpid(self): | return self.__neighbor_ldpid<EOL> | Getter method for neighbor_ldpid, mapped from YANG variable /mpls_state/ldp/ldp_neighbors/neighbor/neighbor_ldpid (inet:ipv4-address)
YANG Description: Neighbor LDP ID | f336395:c0:m3 |
def _set_neighbor_ldpid(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.__neighbor_ldpid = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for neighbor_ldpid, mapped from YANG variable /mpls_state/ldp/ldp_neighbors/neighbor/neighbor_ldpid (inet:ipv4-address)
If this variable is read-only (config: false) in the
source YANG file, then _set_neighbor_ldpid is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_neighbor_ldpid() directly.
YANG Description: Neighbor LDP ID | f336395:c0:m4 |
def _get_labelspaceid(self): | return self.__labelspaceid<EOL> | Getter method for labelspaceid, mapped from YANG variable /mpls_state/ldp/ldp_neighbors/neighbor/labelspaceid (uint8)
YANG Description: labelspaceId | f336395:c0:m6 |
def _set_labelspaceid(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=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, 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.__labelspaceid = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for labelspaceid, mapped from YANG variable /mpls_state/ldp/ldp_neighbors/neighbor/labelspaceid (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_labelspaceid is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_labelspaceid() directly.
YANG Description: labelspaceId | f336395:c0:m7 |
def _get_neighbor_transport(self): | return self.__neighbor_transport<EOL> | Getter method for neighbor_transport, mapped from YANG variable /mpls_state/ldp/ldp_neighbors/neighbor/neighbor_transport (inet:ipv4-address)
YANG Description: Neighbor transport | f336395:c0:m9 |
def _set_neighbor_transport(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.__neighbor_transport = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for neighbor_transport, mapped from YANG variable /mpls_state/ldp/ldp_neighbors/neighbor/neighbor_transport (inet:ipv4-address)
If this variable is read-only (config: false) in the
source YANG file, then _set_neighbor_transport is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_neighbor_transport() directly.
YANG Description: Neighbor transport | f336395:c0:m10 |
def _get_interface_name(self): | return self.__interface_name<EOL> | Getter method for interface_name, mapped from YANG variable /mpls_state/ldp/ldp_neighbors/neighbor/interface_name (string)
YANG Description: Ldp interface name | f336395:c0:m12 |
def _set_interface_name(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__interface_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for interface_name, mapped from YANG variable /mpls_state/ldp/ldp_neighbors/neighbor/interface_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_interface_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_interface_name() directly.
YANG Description: Ldp interface name | f336395:c0:m13 |
def _get_max_hold_time(self): | return self.__max_hold_time<EOL> | Getter method for max_hold_time, mapped from YANG variable /mpls_state/ldp/ldp_neighbors/neighbor/max_hold_time (uint32)
YANG Description: Max hold time | f336395:c0:m15 |
def _set_max_hold_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=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.__max_hold_time = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for max_hold_time, mapped from YANG variable /mpls_state/ldp/ldp_neighbors/neighbor/max_hold_time (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_max_hold_time is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_max_hold_time() directly.
YANG Description: Max hold time | f336395:c0:m16 |
def _get_time_left(self): | return self.__time_left<EOL> | Getter method for time_left, mapped from YANG variable /mpls_state/ldp/ldp_neighbors/neighbor/time_left (uint32)
YANG Description: time left | f336395:c0:m18 |
def _set_time_left(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.__time_left = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for time_left, mapped from YANG variable /mpls_state/ldp/ldp_neighbors/neighbor/time_left (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_time_left is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_time_left() directly.
YANG Description: time left | f336395:c0:m19 |
def _get_up_time(self): | return self.__up_time<EOL> | Getter method for up_time, mapped from YANG variable /mpls_state/ldp/ldp_neighbors/neighbor/up_time (string)
YANG Description: up time | f336395:c0:m21 |
def _set_up_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=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.__up_time = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for up_time, mapped from YANG variable /mpls_state/ldp/ldp_neighbors/neighbor/up_time (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_up_time is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_up_time() directly.
YANG Description: up time | f336395:c0:m22 |
def _get_configured_hold_time(self): | return self.__configured_hold_time<EOL> | Getter method for configured_hold_time, mapped from YANG variable /mpls_state/ldp/ldp_neighbors/neighbor/configured_hold_time (uint32)
YANG Description: configured hold time | f336395:c0:m24 |
def _set_configured_hold_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=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.__configured_hold_time = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for configured_hold_time, mapped from YANG variable /mpls_state/ldp/ldp_neighbors/neighbor/configured_hold_time (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_configured_hold_time is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_configured_hold_time() directly.
YANG Description: configured hold time | f336395:c0:m25 |
def _get_neighbor_proposed_hold_time(self): | return self.__neighbor_proposed_hold_time<EOL> | Getter method for neighbor_proposed_hold_time, mapped from YANG variable /mpls_state/ldp/ldp_neighbors/neighbor/neighbor_proposed_hold_time (uint32)
YANG Description: neighbor proposed hold time | f336395:c0:m27 |
def _set_neighbor_proposed_hold_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=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.__neighbor_proposed_hold_time = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for neighbor_proposed_hold_time, mapped from YANG variable /mpls_state/ldp/ldp_neighbors/neighbor/neighbor_proposed_hold_time (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_neighbor_proposed_hold_time is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_neighbor_proposed_hold_time() directly.
YANG Description: neighbor proposed hold time | f336395:c0:m28 |
def _get_num_link_neighbors(self): | return self.__num_link_neighbors<EOL> | Getter method for num_link_neighbors, mapped from YANG variable /mpls_state/ldp/ldp_neighbors/num_link_neighbors (uint32)
YANG Description: Number of link neighbors | f336396:c0:m3 |
def _set_num_link_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=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.__num_link_neighbors = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for num_link_neighbors, mapped from YANG variable /mpls_state/ldp/ldp_neighbors/num_link_neighbors (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_num_link_neighbors is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_num_link_neighbors() directly.
YANG Description: Number of link neighbors | f336396:c0:m4 |
def _get_num_targeted_neighbors(self): | return self.__num_targeted_neighbors<EOL> | Getter method for num_targeted_neighbors, mapped from YANG variable /mpls_state/ldp/ldp_neighbors/num_targeted_neighbors (uint32)
YANG Description: Number of targeted neighbors | f336396:c0:m6 |
def _set_num_targeted_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=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.__num_targeted_neighbors = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for num_targeted_neighbors, mapped from YANG variable /mpls_state/ldp/ldp_neighbors/num_targeted_neighbors (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_num_targeted_neighbors is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_num_targeted_neighbors() directly.
YANG Description: Number of targeted neighbors | f336396:c0:m7 |
def _get_neighbor(self): | return self.__neighbor<EOL> | Getter method for neighbor, mapped from YANG variable /mpls_state/ldp/ldp_neighbors/neighbor (list)
YANG Description: LDP neighbor details | f336396:c0:m9 |
def _set_neighbor(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>",neighbor.neighbor, 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.__neighbor = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for neighbor, mapped from YANG variable /mpls_state/ldp/ldp_neighbors/neighbor (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_neighbor is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_neighbor() directly.
YANG Description: LDP neighbor details | f336396:c0:m10 |
def _get_ldp_interface_name(self): | return self.__ldp_interface_name<EOL> | Getter method for ldp_interface_name, mapped from YANG variable /mpls_state/ldp/interface/ldp_interface_data/ldp_interface_name (string)
YANG Description: ldp interface name | f336397:c0:m3 |
def _set_ldp_interface_name(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__ldp_interface_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ldp_interface_name, mapped from YANG variable /mpls_state/ldp/interface/ldp_interface_data/ldp_interface_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_ldp_interface_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ldp_interface_name() directly.
YANG Description: ldp interface name | f336397:c0:m4 |
def _get_ldp_interface_type(self): | return self.__ldp_interface_type<EOL> | Getter method for ldp_interface_type, mapped from YANG variable /mpls_state/ldp/interface/ldp_interface_data/ldp_interface_type (string)
YANG Description: ldp interface type | f336397:c0:m6 |
def _set_ldp_interface_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=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.__ldp_interface_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ldp_interface_type, mapped from YANG variable /mpls_state/ldp/interface/ldp_interface_data/ldp_interface_type (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_ldp_interface_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ldp_interface_type() directly.
YANG Description: ldp interface type | f336397:c0:m7 |
def _get_ldp_interface_lbpsp(self): | return self.__ldp_interface_lbpsp<EOL> | Getter method for ldp_interface_lbpsp, mapped from YANG variable /mpls_state/ldp/interface/ldp_interface_data/ldp_interface_lbpsp (uint32)
YANG Description: ldp interface label space | f336397:c0:m9 |
def _set_ldp_interface_lbpsp(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.__ldp_interface_lbpsp = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ldp_interface_lbpsp, mapped from YANG variable /mpls_state/ldp/interface/ldp_interface_data/ldp_interface_lbpsp (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_ldp_interface_lbpsp is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ldp_interface_lbpsp() directly.
YANG Description: ldp interface label space | f336397:c0:m10 |
def _get_ldp_interface_nbr_cnt(self): | return self.__ldp_interface_nbr_cnt<EOL> | Getter method for ldp_interface_nbr_cnt, mapped from YANG variable /mpls_state/ldp/interface/ldp_interface_data/ldp_interface_nbr_cnt (uint32)
YANG Description: ldp interface neighbour count | f336397:c0:m12 |
def _set_ldp_interface_nbr_cnt(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.__ldp_interface_nbr_cnt = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ldp_interface_nbr_cnt, mapped from YANG variable /mpls_state/ldp/interface/ldp_interface_data/ldp_interface_nbr_cnt (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_ldp_interface_nbr_cnt is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ldp_interface_nbr_cnt() directly.
YANG Description: ldp interface neighbour count | f336397:c0:m13 |
def _get_ldp_interface_hello_intl(self): | return self.__ldp_interface_hello_intl<EOL> | Getter method for ldp_interface_hello_intl, mapped from YANG variable /mpls_state/ldp/interface/ldp_interface_data/ldp_interface_hello_intl (uint32)
YANG Description: ldp interface hello interval | f336397:c0:m15 |
def _set_ldp_interface_hello_intl(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.__ldp_interface_hello_intl = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ldp_interface_hello_intl, mapped from YANG variable /mpls_state/ldp/interface/ldp_interface_data/ldp_interface_hello_intl (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_ldp_interface_hello_intl is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ldp_interface_hello_intl() directly.
YANG Description: ldp interface hello interval | f336397:c0:m16 |
def _get_ldp_interface_hello_timeout(self): | return self.__ldp_interface_hello_timeout<EOL> | Getter method for ldp_interface_hello_timeout, mapped from YANG variable /mpls_state/ldp/interface/ldp_interface_data/ldp_interface_hello_timeout (uint32)
YANG Description: ldp interface hello timeout | f336397:c0:m18 |
def _set_ldp_interface_hello_timeout(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.__ldp_interface_hello_timeout = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ldp_interface_hello_timeout, mapped from YANG variable /mpls_state/ldp/interface/ldp_interface_data/ldp_interface_hello_timeout (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_ldp_interface_hello_timeout is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ldp_interface_hello_timeout() directly.
YANG Description: ldp interface hello timeout | f336397:c0:m19 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.