signature stringlengths 8 3.44k | body stringlengths 0 1.41M | docstring stringlengths 1 122k | id stringlengths 5 17 |
|---|---|---|---|
def _get_timers(self): | return self.__timers<EOL> | Getter method for timers, mapped from YANG variable /routing_system/ipv6/router/ospf/timers (container)
YANG Description: Adjust routing timers | f336207:c0:m57 |
def _set_timers(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=timers.timers, 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}}, 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.__timers = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for timers, mapped from YANG variable /routing_system/ipv6/router/ospf/timers (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_timers is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_timers() directly.
YANG Description: Adjust routing timers | f336207:c0:m58 |
def _get_nonstop_routing(self): | return self.__nonstop_routing<EOL> | Getter method for nonstop_routing, mapped from YANG variable /routing_system/ipv6/router/ospf/nonstop_routing (empty)
YANG Description: If the active management module fails, the standby management module takes over andmaintains the current OSPF routes, link-state advertisements (LSAs), and neighbor adjacencies, sothat there is no loss of existing traffic to the OSPF destination. | f336207:c0:m60 |
def _set_nonstop_routing(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>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT:info>': 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.__nonstop_routing = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for nonstop_routing, mapped from YANG variable /routing_system/ipv6/router/ospf/nonstop_routing (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_nonstop_routing is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_nonstop_routing() directly.
YANG Description: If the active management module fails, the standby management module takes over andmaintains the current OSPF routes, link-state advertisements (LSAs), and neighbor adjacencies, sothat there is no loss of existing traffic to the OSPF destination. | f336207:c0:m61 |
def _get_maximum_paths(self): | return self.__maximum_paths<EOL> | Getter method for maximum_paths, mapped from YANG variable /routing_system/ipv6/router/ospf/maximum_paths (uint32)
YANG Description: Set the maximum number of paths to a destination. | f336207:c0:m63 |
def _set_maximum_paths(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>']}), 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:info>': 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.__maximum_paths = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for maximum_paths, mapped from YANG variable /routing_system/ipv6/router/ospf/maximum_paths (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_maximum_paths is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_maximum_paths() directly.
YANG Description: Set the maximum number of paths to a destination. | f336207:c0:m64 |
def _get_max_metric(self): | return self.__max_metric<EOL> | Getter method for max_metric, mapped from YANG variable /routing_system/ipv6/router/ospf/max_metric (container)
YANG Description: The OSPFv3 max-metric router LSA feature enables OSPFv3 to advertise its locally generated router LSAs with a maximum metric to direct transit traffic away from the router, while still routing for directly connected networks.By advertising the maximum metric, the router will not attract transit traffic. A router which does not handle transit traffic and only forwards packets destined for its directly connected links is known as a stub router. In OSPFv3 networks, a device could be placed in a stub router role by advertising large metrics for its connected links, so that the cost of a path through the device becomes larger than that of an alternative path. | f336207:c0:m66 |
def _set_max_metric(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=max_metric.max_metric, 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>': 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.__max_metric = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for max_metric, mapped from YANG variable /routing_system/ipv6/router/ospf/max_metric (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_max_metric is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_max_metric() directly.
YANG Description: The OSPFv3 max-metric router LSA feature enables OSPFv3 to advertise its locally generated router LSAs with a maximum metric to direct transit traffic away from the router, while still routing for directly connected networks.By advertising the maximum metric, the router will not attract transit traffic. A router which does not handle transit traffic and only forwards packets destined for its directly connected links is known as a stub router. In OSPFv3 networks, a device could be placed in a stub router role by advertising large metrics for its connected links, so that the cost of a path through the device becomes larger than that of an alternative path. | f336207:c0:m67 |
def _get_bfd(self): | return self.__bfd<EOL> | Getter method for bfd, mapped from YANG variable /routing_system/ipv6/router/ospf/bfd (container)
YANG Description: BFD provides rapid detection of the failure of a forwarding path by checking that the next-hop device is alive. Without BFD enabled, it can take some time to detect that a neighboring device is not operational causing packet loss due to incorrect routing information at a level unacceptable for real-time applications such as VOIP and video over IP. Using BFD, you can detect a forwarding path failure rapidly depending on the configuration. | f336207:c0:m69 |
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=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}}, 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 /routing_system/ipv6/router/ospf/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.
YANG Description: BFD provides rapid detection of the failure of a forwarding path by checking that the next-hop device is alive. Without BFD enabled, it can take some time to detect that a neighboring device is not operational causing packet loss due to incorrect routing information at a level unacceptable for real-time applications such as VOIP and video over IP. Using BFD, you can detect a forwarding path failure rapidly depending on the configuration. | f336207:c0:m70 |
def _get_vrf_lite_capability(self): | return self.__vrf_lite_capability<EOL> | Getter method for vrf_lite_capability, mapped from YANG variable /routing_system/ipv6/router/ospf/vrf_lite_capability (empty) | f336207:c0:m72 |
def _set_vrf_lite_capability(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:info>': 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.__vrf_lite_capability = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vrf_lite_capability, mapped from YANG variable /routing_system/ipv6/router/ospf/vrf_lite_capability (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_vrf_lite_capability is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vrf_lite_capability() directly. | f336207:c0:m73 |
def _get_auth_transition(self): | return self.__auth_transition<EOL> | Getter method for auth_transition, mapped from YANG variable /routing_system/ipv6/router/ospf/auth_transition (empty) | f336207:c0:m75 |
def _set_auth_transition(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:info>': 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.__auth_transition = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for auth_transition, mapped from YANG variable /routing_system/ipv6/router/ospf/auth_transition (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_auth_transition is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_auth_transition() directly. | f336207:c0:m76 |
def _get_virt_link_neighbor(self): | return self.__virt_link_neighbor<EOL> | Getter method for virt_link_neighbor, mapped from YANG variable /routing_system/router/ospf/area/virtual_link/virt_link_neighbor (inet:ipv4-address) | f336208:c0:m3 |
def _set_virt_link_neighbor(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=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.__virt_link_neighbor = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for virt_link_neighbor, mapped from YANG variable /routing_system/router/ospf/area/virtual_link/virt_link_neighbor (inet:ipv4-address)
If this variable is read-only (config: false) in the
source YANG file, then _set_virt_link_neighbor is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_virt_link_neighbor() directly. | f336208:c0:m4 |
def _get_authentication_key(self): | return self.__authentication_key<EOL> | Getter method for authentication_key, mapped from YANG variable /routing_system/router/ospf/area/virtual_link/authentication_key (container) | f336208:c0:m6 |
def _set_authentication_key(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=authentication_key.authentication_key, 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.__authentication_key = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for authentication_key, mapped from YANG variable /routing_system/router/ospf/area/virtual_link/authentication_key (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_authentication_key is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_authentication_key() directly. | f336208:c0:m7 |
def _get_authentication(self): | return self.__authentication<EOL> | Getter method for authentication, mapped from YANG variable /routing_system/router/ospf/area/virtual_link/authentication (container)
YANG Description: Authentication of OSPF messages | f336208:c0:m9 |
def _set_authentication(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=authentication.authentication, 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.__authentication = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for authentication, mapped from YANG variable /routing_system/router/ospf/area/virtual_link/authentication (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_authentication is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_authentication() directly.
YANG Description: Authentication of OSPF messages | f336208:c0:m10 |
def _get_hello_interval(self): | return self.__hello_interval<EOL> | Getter method for hello_interval, mapped from YANG variable /routing_system/router/ospf/area/virtual_link/hello_interval (common-def:time-interval-sec) | f336208:c0:m12 |
def _set_hello_interval(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=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:10>), 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>'}}, 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.__hello_interval = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for hello_interval, mapped from YANG variable /routing_system/router/ospf/area/virtual_link/hello_interval (common-def:time-interval-sec)
If this variable is read-only (config: false) in the
source YANG file, then _set_hello_interval is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_hello_interval() directly. | f336208:c0:m13 |
def _get_dead_interval(self): | return self.__dead_interval<EOL> | Getter method for dead_interval, mapped from YANG variable /routing_system/router/ospf/area/virtual_link/dead_interval (common-def:time-interval-sec) | f336208:c0:m15 |
def _set_dead_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>'}}, 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.__dead_interval = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for dead_interval, mapped from YANG variable /routing_system/router/ospf/area/virtual_link/dead_interval (common-def:time-interval-sec)
If this variable is read-only (config: false) in the
source YANG file, then _set_dead_interval is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_dead_interval() directly. | f336208:c0:m16 |
def _get_retransmit_interval(self): | return self.__retransmit_interval<EOL> | Getter method for retransmit_interval, mapped from YANG variable /routing_system/router/ospf/area/virtual_link/retransmit_interval (common-def:time-interval-sec) | f336208:c0:m18 |
def _set_retransmit_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>']}), 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>'}}, 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.__retransmit_interval = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for retransmit_interval, mapped from YANG variable /routing_system/router/ospf/area/virtual_link/retransmit_interval (common-def:time-interval-sec)
If this variable is read-only (config: false) in the
source YANG file, then _set_retransmit_interval is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_retransmit_interval() directly. | f336208:c0:m19 |
def _get_transmit_delay(self): | return self.__transmit_delay<EOL> | Getter method for transmit_delay, mapped from YANG variable /routing_system/router/ospf/area/virtual_link/transmit_delay (common-def:time-interval-sec) | f336208:c0:m21 |
def _set_transmit_delay(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), 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, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': 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.__transmit_delay = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for transmit_delay, mapped from YANG variable /routing_system/router/ospf/area/virtual_link/transmit_delay (common-def:time-interval-sec)
If this variable is read-only (config: false) in the
source YANG file, then _set_transmit_delay is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_transmit_delay() directly. | f336208:c0:m22 |
def _get_md5_authentication(self): | return self.__md5_authentication<EOL> | Getter method for md5_authentication, mapped from YANG variable /routing_system/router/ospf/area/virtual_link/md5_authentication (container) | f336208:c0:m24 |
def _set_md5_authentication(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=md5_authentication.md5_authentication, 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.__md5_authentication = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for md5_authentication, mapped from YANG variable /routing_system/router/ospf/area/virtual_link/md5_authentication (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_md5_authentication is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_md5_authentication() directly. | f336208:c0:m25 |
def _get_key_chain(self): | return self.__key_chain<EOL> | Getter method for key_chain, mapped from YANG variable /routing_system/router/ospf/area/virtual_link/authentication/key_chain (ospf-keychain-string) | f336209:c0:m3 |
def _set_key_chain(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, 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.__key_chain = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for key_chain, mapped from YANG variable /routing_system/router/ospf/area/virtual_link/authentication/key_chain (ospf-keychain-string)
If this variable is read-only (config: false) in the
source YANG file, then _set_key_chain is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_key_chain() directly. | f336209:c0:m4 |
def _get_vrf(self): | return self.__vrf<EOL> | Getter method for vrf, mapped from YANG variable /routing_system/router/ospf/vrf (string) | f336210:c0:m3 |
def _set_vrf(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, 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}}, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=True)<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.__vrf = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vrf, mapped from YANG variable /routing_system/router/ospf/vrf (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_vrf is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vrf() directly. | f336210:c0:m4 |
def _get_database_overflow_interval(self): | return self.__database_overflow_interval<EOL> | Getter method for database_overflow_interval, mapped from YANG variable /routing_system/router/ospf/database_overflow_interval (common-def:time-interval-sec) | f336210:c0:m6 |
def _set_database_overflow_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>']}), 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:info>': 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.__database_overflow_interval = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for database_overflow_interval, mapped from YANG variable /routing_system/router/ospf/database_overflow_interval (common-def:time-interval-sec)
If this variable is read-only (config: false) in the
source YANG file, then _set_database_overflow_interval is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_database_overflow_interval() directly. | f336210:c0:m7 |
def _get_default_information_originate(self): | return self.__default_information_originate<EOL> | Getter method for default_information_originate, mapped from YANG variable /routing_system/router/ospf/default_information_originate (container) | f336210:c0:m9 |
def _set_default_information_originate(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=default_information_originate.default_information_originate, 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>': None, u'<STR_LIT:info>': 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.__default_information_originate = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for default_information_originate, mapped from YANG variable /routing_system/router/ospf/default_information_originate (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_default_information_originate is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_default_information_originate() directly. | f336210:c0:m10 |
def _get_default_passive_interface(self): | return self.__default_passive_interface<EOL> | Getter method for default_passive_interface, mapped from YANG variable /routing_system/router/ospf/default_passive_interface (empty) | f336210:c0:m12 |
def _set_default_passive_interface(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': 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.__default_passive_interface = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for default_passive_interface, mapped from YANG variable /routing_system/router/ospf/default_passive_interface (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_default_passive_interface is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_default_passive_interface() directly. | f336210:c0:m13 |
def _get_default_metric(self): | return self.__default_metric<EOL> | Getter method for default_metric, mapped from YANG variable /routing_system/router/ospf/default_metric (uint32) | f336210:c0:m15 |
def _set_default_metric(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:10>), 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>'}}, 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.__default_metric = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for default_metric, mapped from YANG variable /routing_system/router/ospf/default_metric (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_default_metric is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_default_metric() directly. | f336210:c0:m16 |
def _get_ldp_sync(self): | return self.__ldp_sync<EOL> | Getter method for ldp_sync, mapped from YANG variable /routing_system/router/ospf/ldp_sync (container) | f336210:c0:m18 |
def _set_ldp_sync(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=ldp_sync.ldp_sync, 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>': None, u'<STR_LIT:info>': 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_sync = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ldp_sync, mapped from YANG variable /routing_system/router/ospf/ldp_sync (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_ldp_sync is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ldp_sync() directly. | f336210:c0:m19 |
def _get_external_lsdb_limit(self): | return self.__external_lsdb_limit<EOL> | Getter method for external_lsdb_limit, mapped from YANG variable /routing_system/router/ospf/external_lsdb_limit (uint32) | f336210:c0:m21 |
def _set_external_lsdb_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>']}), 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:info>': 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.__external_lsdb_limit = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for external_lsdb_limit, mapped from YANG variable /routing_system/router/ospf/external_lsdb_limit (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_external_lsdb_limit is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_external_lsdb_limit() directly. | f336210:c0:m22 |
def _get_log(self): | return self.__log<EOL> | Getter method for log, mapped from YANG variable /routing_system/router/ospf/log (container) | f336210:c0:m24 |
def _set_log(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=log.log, 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>'}}, 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.__log = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for log, mapped from YANG variable /routing_system/router/ospf/log (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_log is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_log() directly. | f336210:c0:m25 |
def _get_ospf_metric_type(self): | return self.__ospf_metric_type<EOL> | Getter method for ospf_metric_type, mapped from YANG variable /routing_system/router/ospf/ospf_metric_type (metric-type) | f336210:c0:m27 |
def _set_ospf_metric_type(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT: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, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', 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.__ospf_metric_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ospf_metric_type, mapped from YANG variable /routing_system/router/ospf/ospf_metric_type (metric-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_ospf_metric_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ospf_metric_type() directly. | f336210:c0:m28 |
def _get_neighbor(self): | return self.__neighbor<EOL> | Getter method for neighbor, mapped from YANG variable /routing_system/router/ospf/neighbor (list) | f336210:c0:m30 |
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:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None, 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:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None}}, 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.__neighbor = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for neighbor, mapped from YANG variable /routing_system/router/ospf/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. | f336210:c0:m31 |
def _get_redistribute(self): | return self.__redistribute<EOL> | Getter method for redistribute, mapped from YANG variable /routing_system/router/ospf/redistribute (container) | f336210:c0:m33 |
def _set_redistribute(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=redistribute.redistribute, 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}}, 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.__redistribute = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for redistribute, mapped from YANG variable /routing_system/router/ospf/redistribute (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_redistribute is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_redistribute() directly. | f336210:c0:m34 |
def _get_rfc1583_compatibility(self): | return self.__rfc1583_compatibility<EOL> | Getter method for rfc1583_compatibility, mapped from YANG variable /routing_system/router/ospf/rfc1583_compatibility (container) | f336210:c0:m36 |
def _set_rfc1583_compatibility(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=rfc1583_compatibility.rfc1583_compatibility, 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>': 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.__rfc1583_compatibility = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rfc1583_compatibility, mapped from YANG variable /routing_system/router/ospf/rfc1583_compatibility (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_rfc1583_compatibility is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rfc1583_compatibility() directly. | f336210:c0:m37 |
def _get_area(self): | return self.__area<EOL> | Getter method for area, mapped from YANG variable /routing_system/router/ospf/area (list) | f336210:c0:m39 |
def _set_area(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGListType("<STR_LIT>",area.area, 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}}), 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}}, 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.__area = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for area, mapped from YANG variable /routing_system/router/ospf/area (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_area is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_area() directly. | f336210:c0:m40 |
def _get_auto_cost(self): | return self.__auto_cost<EOL> | Getter method for auto_cost, mapped from YANG variable /routing_system/router/ospf/auto_cost (container) | f336210:c0:m42 |
def _set_auto_cost(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=auto_cost.auto_cost, 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>'}}, 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.__auto_cost = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for auto_cost, mapped from YANG variable /routing_system/router/ospf/auto_cost (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_auto_cost is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_auto_cost() directly. | f336210:c0:m43 |
def _get_distance(self): | return self.__distance<EOL> | Getter method for distance, mapped from YANG variable /routing_system/router/ospf/distance (list) | f336210:c0:m45 |
def _set_distance(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>",distance.distance, 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>': 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>': None, 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.__distance = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for distance, mapped from YANG variable /routing_system/router/ospf/distance (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_distance is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_distance() directly. | f336210:c0:m46 |
def _get_distribute_list(self): | return self.__distribute_list<EOL> | Getter method for distribute_list, mapped from YANG variable /routing_system/router/ospf/distribute_list (container) | f336210:c0:m48 |
def _set_distribute_list(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=distribute_list.distribute_list, 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>'}}, 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.__distribute_list = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for distribute_list, mapped from YANG variable /routing_system/router/ospf/distribute_list (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_distribute_list is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_distribute_list() directly. | f336210:c0:m49 |
def _get_max_metric(self): | return self.__max_metric<EOL> | Getter method for max_metric, mapped from YANG variable /routing_system/router/ospf/max_metric (container) | f336210:c0:m51 |
def _set_max_metric(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=max_metric.max_metric, 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>': 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.__max_metric = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for max_metric, mapped from YANG variable /routing_system/router/ospf/max_metric (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_max_metric is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_max_metric() directly. | f336210:c0:m52 |
def _get_summary_address(self): | return self.__summary_address<EOL> | Getter method for summary_address, mapped from YANG variable /routing_system/router/ospf/summary_address (list) | f336210:c0:m54 |
def _set_summary_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=YANGListType("<STR_LIT>",summary_address.summary_address, 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>': u'<STR_LIT>', u'<STR_LIT>': None, 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:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None}}, 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.__summary_address = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for summary_address, mapped from YANG variable /routing_system/router/ospf/summary_address (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_summary_address is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_summary_address() directly. | f336210:c0:m55 |
def _get_timers(self): | return self.__timers<EOL> | Getter method for timers, mapped from YANG variable /routing_system/router/ospf/timers (container) | f336210:c0:m57 |
def _set_timers(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=timers.timers, 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}}, 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.__timers = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for timers, mapped from YANG variable /routing_system/router/ospf/timers (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_timers is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_timers() directly. | f336210:c0:m58 |
def _get_permit(self): | return self.__permit<EOL> | Getter method for permit, mapped from YANG variable /routing_system/router/ospf/permit (container) | f336210:c0:m60 |
def _set_permit(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=permit.permit, 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>': 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.__permit = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for permit, mapped from YANG variable /routing_system/router/ospf/permit (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_permit is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_permit() directly. | f336210:c0:m61 |
def _get_deny(self): | return self.__deny<EOL> | Getter method for deny, mapped from YANG variable /routing_system/router/ospf/deny (container) | f336210:c0:m63 |
def _set_deny(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=deny.deny, 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>': 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.__deny = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for deny, mapped from YANG variable /routing_system/router/ospf/deny (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_deny is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_deny() directly. | f336210:c0:m64 |
def _get_vrf_lite_capability(self): | return self.__vrf_lite_capability<EOL> | Getter method for vrf_lite_capability, mapped from YANG variable /routing_system/router/ospf/vrf_lite_capability (empty) | f336210:c0:m66 |
def _set_vrf_lite_capability(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:info>': 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.__vrf_lite_capability = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vrf_lite_capability, mapped from YANG variable /routing_system/router/ospf/vrf_lite_capability (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_vrf_lite_capability is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vrf_lite_capability() directly. | f336210:c0:m67 |
def _get_graceful_restart(self): | return self.__graceful_restart<EOL> | Getter method for graceful_restart, mapped from YANG variable /routing_system/router/ospf/graceful_restart (container)
YANG Description: Enables the OSPF graceful restart capability | f336210:c0:m69 |
def _set_graceful_restart(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=graceful_restart.graceful_restart, 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}}, 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.__graceful_restart = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for graceful_restart, mapped from YANG variable /routing_system/router/ospf/graceful_restart (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_graceful_restart is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_graceful_restart() directly.
YANG Description: Enables the OSPF graceful restart capability | f336210:c0:m70 |
def _get_nonstop_routing(self): | return self.__nonstop_routing<EOL> | Getter method for nonstop_routing, mapped from YANG variable /routing_system/router/ospf/nonstop_routing (empty) | f336210:c0:m72 |
def _set_nonstop_routing(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>'}}, 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.__nonstop_routing = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for nonstop_routing, mapped from YANG variable /routing_system/router/ospf/nonstop_routing (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_nonstop_routing is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_nonstop_routing() directly. | f336210:c0:m73 |
def _get_maximum_paths(self): | return self.__maximum_paths<EOL> | Getter method for maximum_paths, mapped from YANG variable /routing_system/router/ospf/maximum_paths (uint8)
YANG Description: The maximum number of paths to a destination. | f336210:c0:m75 |
def _set_maximum_paths(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=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:8>), 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, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': 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.__maximum_paths = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for maximum_paths, mapped from YANG variable /routing_system/router/ospf/maximum_paths (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_maximum_paths is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_maximum_paths() directly.
YANG Description: The maximum number of paths to a destination. | f336210:c0:m76 |
def _get_global_bfd(self): | return self.__global_bfd<EOL> | Getter method for global_bfd, mapped from YANG variable /routing_system/router/ospf/global_bfd (container)
YANG Description: Configure BFD for OSPFv2 on all OSPFv2 enabled interfaces | f336210:c0:m78 |
def _set_global_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=global_bfd.global_bfd, 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>': 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.__global_bfd = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for global_bfd, mapped from YANG variable /routing_system/router/ospf/global_bfd (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_global_bfd is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_global_bfd() directly.
YANG Description: Configure BFD for OSPFv2 on all OSPFv2 enabled interfaces | f336210:c0:m79 |
def _get_auth_transition(self): | return self.__auth_transition<EOL> | Getter method for auth_transition, mapped from YANG variable /routing_system/router/ospf/auth_transition (empty) | f336210:c0:m81 |
def _set_auth_transition(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.__auth_transition = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for auth_transition, mapped from YANG variable /routing_system/router/ospf/auth_transition (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_auth_transition is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_auth_transition() directly. | f336210:c0:m82 |
def _get_default_vrf(self): | return self.__default_vrf<EOL> | Getter method for default_vrf, mapped from YANG variable /routing_system/router/router_bgp/address_family/ipv4/ipv4_unicast/default_vrf (container) | f336211:c0:m3 |
def _set_default_vrf(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=default_vrf.default_vrf, 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, 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>', 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.__default_vrf = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for default_vrf, mapped from YANG variable /routing_system/router/router_bgp/address_family/ipv4/ipv4_unicast/default_vrf (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_default_vrf is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_default_vrf() directly. | f336211:c0:m4 |
def _get_af_vrf(self): | return self.__af_vrf<EOL> | Getter method for af_vrf, mapped from YANG variable /routing_system/router/router_bgp/address_family/ipv4/ipv4_unicast/af_vrf (list) | f336211:c0:m6 |
def _set_af_vrf(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>",af_vrf.af_vrf, 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>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>', 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>': None, u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None, 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: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.__af_vrf = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for af_vrf, mapped from YANG variable /routing_system/router/router_bgp/address_family/ipv4/ipv4_unicast/af_vrf (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_af_vrf is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_af_vrf() directly. | f336211:c0:m7 |
def _get_bgp_redistribute_internal(self): | return self.__bgp_redistribute_internal<EOL> | Getter method for bgp_redistribute_internal, mapped from YANG variable /routing_system/router/router_bgp/address_family/ipv4/ipv4_unicast/default_vrf/af_ipv4_uc_and_vrf_cmds_call_point_holder/bgp_redistribute_internal (empty) | f336212:c0:m3 |
def _set_bgp_redistribute_internal(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>'}}, 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.__bgp_redistribute_internal = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for bgp_redistribute_internal, mapped from YANG variable /routing_system/router/router_bgp/address_family/ipv4/ipv4_unicast/default_vrf/af_ipv4_uc_and_vrf_cmds_call_point_holder/bgp_redistribute_internal (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_bgp_redistribute_internal is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_bgp_redistribute_internal() directly. | f336212:c0:m4 |
def _get_redistribute(self): | return self.__redistribute<EOL> | Getter method for redistribute, mapped from YANG variable /routing_system/router/router_bgp/address_family/ipv4/ipv4_unicast/default_vrf/af_ipv4_uc_and_vrf_cmds_call_point_holder/redistribute (container) | f336212:c0:m6 |
def _set_redistribute(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=redistribute.redistribute, 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.__redistribute = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for redistribute, mapped from YANG variable /routing_system/router/router_bgp/address_family/ipv4/ipv4_unicast/default_vrf/af_ipv4_uc_and_vrf_cmds_call_point_holder/redistribute (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_redistribute is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_redistribute() directly. | f336212:c0:m7 |
def _get_af_additional_paths(self): | return self.__af_additional_paths<EOL> | Getter method for af_additional_paths, mapped from YANG variable /routing_system/router/router_bgp/address_family/ipv4/ipv4_unicast/default_vrf/af_ipv4_uc_and_vrf_cmds_call_point_holder/af_additional_paths (container) | f336212:c0:m9 |
def _set_af_additional_paths(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=af_additional_paths.af_additional_paths, 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>': 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.__af_additional_paths = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for af_additional_paths, mapped from YANG variable /routing_system/router/router_bgp/address_family/ipv4/ipv4_unicast/default_vrf/af_ipv4_uc_and_vrf_cmds_call_point_holder/af_additional_paths (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_af_additional_paths is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_af_additional_paths() directly. | f336212:c0:m10 |
def _get_advertise_best_external(self): | return self.__advertise_best_external<EOL> | Getter method for advertise_best_external, mapped from YANG variable /routing_system/router/router_bgp/address_family/ipv4/ipv4_unicast/default_vrf/af_ipv4_uc_and_vrf_cmds_call_point_holder/advertise_best_external (empty) | f336212:c0:m12 |
def _set_advertise_best_external(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:info>': 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.__advertise_best_external = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for advertise_best_external, mapped from YANG variable /routing_system/router/router_bgp/address_family/ipv4/ipv4_unicast/default_vrf/af_ipv4_uc_and_vrf_cmds_call_point_holder/advertise_best_external (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_advertise_best_external is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_advertise_best_external() directly. | f336212:c0:m13 |
def _get_addpath_sel_best(self): | return self.__addpath_sel_best<EOL> | Getter method for addpath_sel_best, mapped from YANG variable /routing_system/router/router_bgp/address_family/ipv4/ipv4_unicast/default_vrf/af_ipv4_uc_and_vrf_cmds_call_point_holder/af_additional_paths/addpath_select/addpath_sel_best (uint8) | f336213:c0:m3 |
def _set_addpath_sel_best(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=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:8>), 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, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u"<STR_LIT>", 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.__addpath_sel_best = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for addpath_sel_best, mapped from YANG variable /routing_system/router/router_bgp/address_family/ipv4/ipv4_unicast/default_vrf/af_ipv4_uc_and_vrf_cmds_call_point_holder/af_additional_paths/addpath_select/addpath_sel_best (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_addpath_sel_best is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_addpath_sel_best() directly. | f336213:c0:m4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.