signature stringlengths 8 3.44k | body stringlengths 0 1.41M | docstring stringlengths 1 122k | id stringlengths 5 17 |
|---|---|---|---|
def _get_tag(self): | return self.__tag<EOL> | Getter method for tag, mapped from YANG variable /routing_system/route_map/content/match/tag (container)
YANG Description: Route tag. | f336192:c0:m27 |
def _set_tag(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=tag.tag, 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.__tag = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for tag, mapped from YANG variable /routing_system/route_map/content/match/tag (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_tag is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tag() directly.
YANG Description: Route tag. | f336192:c0:m28 |
def _get_as_path(self): | return self.__as_path<EOL> | Getter method for as_path, mapped from YANG variable /routing_system/route_map/content/match/as_path (container)
YANG Description: IP AS Path Access Lists. | f336192:c0:m30 |
def _set_as_path(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=as_path.as_path, 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.__as_path = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for as_path, mapped from YANG variable /routing_system/route_map/content/match/as_path (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_as_path is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_as_path() directly.
YANG Description: IP AS Path Access Lists. | f336192:c0:m31 |
def _get_community(self): | return self.__community<EOL> | Getter method for community, mapped from YANG variable /routing_system/route_map/content/match/community (container)
YANG Description: Community Access List Name. | f336192:c0:m33 |
def _set_community(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=community.community, 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}}, 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.__community = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for community, mapped from YANG variable /routing_system/route_map/content/match/community (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_community is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_community() directly.
YANG Description: Community Access List Name. | f336192:c0:m34 |
def _get_next_hop(self): | return self.__next_hop<EOL> | Getter method for next_hop, mapped from YANG variable /routing_system/route_map/content/match/next_hop (container)
YANG Description: Next hop address filter | f336192:c0:m36 |
def _set_next_hop(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=next_hop.next_hop, 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.__next_hop = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for next_hop, mapped from YANG variable /routing_system/route_map/content/match/next_hop (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_next_hop is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_next_hop() directly.
YANG Description: Next hop address filter | f336192:c0:m37 |
def _get_protocol(self): | return self.__protocol<EOL> | Getter method for protocol, mapped from YANG variable /routing_system/route_map/content/match/protocol (container)
YANG Description: Match route on protocol type and sub-type. | f336192:c0:m39 |
def _set_protocol(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=protocol.protocol, 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.__protocol = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for protocol, mapped from YANG variable /routing_system/route_map/content/match/protocol (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_protocol is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_protocol() directly.
YANG Description: Match route on protocol type and sub-type. | f336192:c0:m40 |
def _get_evpn(self): | return self.__evpn<EOL> | Getter method for evpn, mapped from YANG variable /routing_system/evpn_config/evpn (container) | f336193:c0:m3 |
def _set_evpn(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=evpn.evpn, 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.__evpn = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for evpn, mapped from YANG variable /routing_system/evpn_config/evpn (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_evpn is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_evpn() directly. | f336193:c0:m4 |
def _get_bd_range_add(self): | return self.__bd_range_add<EOL> | Getter method for bd_range_add, mapped from YANG variable /routing_system/evpn_config/evpn/evpn_instance/bridge_domain/bd_add/bd_range_add (bridge-domain:ui32-bridge-domain-range)
YANG Description: Add bridge domains to the EVPN Instance. | f336194:c0:m3 |
def _set_bd_range_add(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>', '<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}}, 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.__bd_range_add = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for bd_range_add, mapped from YANG variable /routing_system/evpn_config/evpn/evpn_instance/bridge_domain/bd_add/bd_range_add (bridge-domain:ui32-bridge-domain-range)
If this variable is read-only (config: false) in the
source YANG file, then _set_bd_range_add is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_bd_range_add() directly.
YANG Description: Add bridge domains to the EVPN Instance. | f336194:c0:m4 |
def _get_bd_range_remove(self): | return self.__bd_range_remove<EOL> | Getter method for bd_range_remove, mapped from YANG variable /routing_system/evpn_config/evpn/evpn_instance/bridge_domain/bd_add/bd_range_remove (bridge-domain:ui32-bridge-domain-range)
YANG Description: Remove bridge domains to the EVPN Instance. | f336194:c0:m6 |
def _set_bd_range_remove(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>', '<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}}, 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.__bd_range_remove = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for bd_range_remove, mapped from YANG variable /routing_system/evpn_config/evpn/evpn_instance/bridge_domain/bd_add/bd_range_remove (bridge-domain:ui32-bridge-domain-range)
If this variable is read-only (config: false) in the
source YANG file, then _set_bd_range_remove is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_bd_range_remove() directly.
YANG Description: Remove bridge domains to the EVPN Instance. | f336194:c0:m7 |
def _get_bd_number(self): | return self.__bd_number<EOL> | Getter method for bd_number, mapped from YANG variable /routing_system/evpn_config/evpn/evpn_instance/bridge_domain/evpn_bd/bd_number (bridge-domain:bridge-domain-id-type) | f336195:c0:m3 |
def _set_bd_number(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=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>': None}}, 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.__bd_number = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for bd_number, mapped from YANG variable /routing_system/evpn_config/evpn/evpn_instance/bridge_domain/evpn_bd/bd_number (bridge-domain:bridge-domain-id-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_bd_number is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_bd_number() directly. | f336195:c0:m4 |
def _get_rd(self): | return self.__rd<EOL> | Getter method for rd, mapped from YANG variable /routing_system/evpn_config/evpn/evpn_instance/bridge_domain/evpn_bd/rd (rd-type) | f336195:c0:m6 |
def _set_rd(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, 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.__rd = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rd, mapped from YANG variable /routing_system/evpn_config/evpn/evpn_instance/bridge_domain/evpn_bd/rd (rd-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_rd is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rd() directly. | f336195:c0:m7 |
def _get_route_target(self): | return self.__route_target<EOL> | Getter method for route_target, mapped from YANG variable /routing_system/evpn_config/evpn/evpn_instance/bridge_domain/evpn_bd/route_target (container) | f336195:c0:m9 |
def _set_route_target(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=route_target.route_target, 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.__route_target = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for route_target, mapped from YANG variable /routing_system/evpn_config/evpn/evpn_instance/bridge_domain/evpn_bd/route_target (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_route_target is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_route_target() directly. | f336195:c0:m10 |
def _get_target_community(self): | return self.__target_community<EOL> | Getter method for target_community, mapped from YANG variable /routing_system/evpn_config/evpn/evpn_instance/route_target/export/target_community (rt-type)
YANG Description: Target VPN Extended Community | f336196:c0:m3 |
def _set_target_community(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, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, 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.__target_community = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for target_community, mapped from YANG variable /routing_system/evpn_config/evpn/evpn_instance/route_target/export/target_community (rt-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_target_community is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_target_community() directly.
YANG Description: Target VPN Extended Community | f336196:c0:m4 |
def _get_target_community(self): | return self.__target_community<EOL> | Getter method for target_community, mapped from YANG variable /routing_system/evpn_config/evpn/evpn_instance/route_target/both/target_community (rt-type)
YANG Description: Target VPN Extended Community | f336197:c0:m3 |
def _set_target_community(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, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, 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.__target_community = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for target_community, mapped from YANG variable /routing_system/evpn_config/evpn/evpn_instance/route_target/both/target_community (rt-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_target_community is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_target_community() directly.
YANG Description: Target VPN Extended Community | f336197:c0:m4 |
def _get_ignore_as(self): | return self.__ignore_as<EOL> | Getter method for ignore_as, mapped from YANG variable /routing_system/evpn_config/evpn/evpn_instance/route_target/both/ignore_as (empty) | f336197:c0:m6 |
def _set_ignore_as(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.__ignore_as = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ignore_as, mapped from YANG variable /routing_system/evpn_config/evpn/evpn_instance/route_target/both/ignore_as (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_ignore_as is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ignore_as() directly. | f336197:c0:m7 |
def _get_target_community(self): | return self.__target_community<EOL> | Getter method for target_community, mapped from YANG variable /routing_system/evpn_config/evpn/evpn_instance/route_target/import/target_community (rt-type)
YANG Description: Target VPN Extended Community | f336198:c0:m3 |
def _set_target_community(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, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, 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.__target_community = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for target_community, mapped from YANG variable /routing_system/evpn_config/evpn/evpn_instance/route_target/import/target_community (rt-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_target_community is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_target_community() directly.
YANG Description: Target VPN Extended Community | f336198:c0:m4 |
def _get_ignore_as(self): | return self.__ignore_as<EOL> | Getter method for ignore_as, mapped from YANG variable /routing_system/evpn_config/evpn/evpn_instance/route_target/import/ignore_as (empty) | f336198:c0:m6 |
def _set_ignore_as(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.__ignore_as = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ignore_as, mapped from YANG variable /routing_system/evpn_config/evpn/evpn_instance/route_target/import/ignore_as (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_ignore_as is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ignore_as() directly. | f336198:c0:m7 |
def _get_static_ag_ip_config(self): | return self.__static_ag_ip_config<EOL> | Getter method for static_ag_ip_config, mapped from YANG variable /routing_system/ip/static_ag_ip_config (container) | f336199:c0:m3 |
def _set_static_ag_ip_config(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=static_ag_ip_config.static_ag_ip_config, 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>': 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.__static_ag_ip_config = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for static_ag_ip_config, mapped from YANG variable /routing_system/ip/static_ag_ip_config (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_static_ag_ip_config is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_static_ag_ip_config() directly. | f336199:c0:m4 |
def _get_dhcp(self): | return self.__dhcp<EOL> | Getter method for dhcp, mapped from YANG variable /routing_system/ip/dhcp (container)
YANG Description: DHCP Global Configuration | f336199:c0:m6 |
def _set_dhcp(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=dhcp.dhcp, 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.__dhcp = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for dhcp, mapped from YANG variable /routing_system/ip/dhcp (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_dhcp is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_dhcp() directly.
YANG Description: DHCP Global Configuration | f336199:c0:m7 |
def _get_receive(self): | return self.__receive<EOL> | Getter method for receive, mapped from YANG variable /routing_system/ip/receive (container) | f336199:c0:m9 |
def _set_receive(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=receive.receive, 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.__receive = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for receive, mapped from YANG variable /routing_system/ip/receive (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_receive is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_receive() directly. | f336199:c0:m10 |
def _get_anycast_gateway_mac(self): | return self.__anycast_gateway_mac<EOL> | Getter method for anycast_gateway_mac, mapped from YANG variable /routing_system/ip/static_ag_ip_config/anycast_gateway_mac (container)
YANG Description: Anycast gateway MAC address. | f336200:c0:m3 |
def _set_anycast_gateway_mac(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=anycast_gateway_mac.anycast_gateway_mac, 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.__anycast_gateway_mac = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for anycast_gateway_mac, mapped from YANG variable /routing_system/ip/static_ag_ip_config/anycast_gateway_mac (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_anycast_gateway_mac is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_anycast_gateway_mac() directly.
YANG Description: Anycast gateway MAC address. | f336200:c0:m4 |
def _get_ip_anycast_gateway_mac(self): | return self.__ip_anycast_gateway_mac<EOL> | Getter method for ip_anycast_gateway_mac, mapped from YANG variable /routing_system/ip/static_ag_ip_config/anycast_gateway_mac/ip_anycast_gateway_mac (mac-access-list:mac-address-type) | f336201:c0:m3 |
def _set_ip_anycast_gateway_mac(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, extensions={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.__ip_anycast_gateway_mac = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ip_anycast_gateway_mac, mapped from YANG variable /routing_system/ip/static_ag_ip_config/anycast_gateway_mac/ip_anycast_gateway_mac (mac-access-list:mac-address-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_ip_anycast_gateway_mac is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ip_anycast_gateway_mac() directly. | f336201:c0:m4 |
def _get_ip_anycast_default_mac(self): | return self.__ip_anycast_default_mac<EOL> | Getter method for ip_anycast_default_mac, mapped from YANG variable /routing_system/ip/static_ag_ip_config/anycast_gateway_mac/ip_anycast_default_mac (empty)
YANG Description: Anycast gateway default MAC. | f336201:c0:m6 |
def _set_ip_anycast_default_mac(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>': 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.__ip_anycast_default_mac = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ip_anycast_default_mac, mapped from YANG variable /routing_system/ip/static_ag_ip_config/anycast_gateway_mac/ip_anycast_default_mac (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_ip_anycast_default_mac is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ip_anycast_default_mac() directly.
YANG Description: Anycast gateway default MAC. | f336201:c0:m7 |
def _get_router(self): | return self.__router<EOL> | Getter method for router, mapped from YANG variable /routing_system/ipv6/router (container)
YANG Description: The ipv6 routing system. | f336202:c0:m3 |
def _set_router(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=router.router, 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>': 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.__router = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for router, mapped from YANG variable /routing_system/ipv6/router (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_router is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_router() directly.
YANG Description: The ipv6 routing system. | f336202:c0:m4 |
def _get_static_ag_ipv6_config(self): | return self.__static_ag_ipv6_config<EOL> | Getter method for static_ag_ipv6_config, mapped from YANG variable /routing_system/ipv6/static_ag_ipv6_config (container) | f336202:c0:m6 |
def _set_static_ag_ipv6_config(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=static_ag_ipv6_config.static_ag_ipv6_config, 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>': 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.__static_ag_ipv6_config = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for static_ag_ipv6_config, mapped from YANG variable /routing_system/ipv6/static_ag_ipv6_config (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_static_ag_ipv6_config is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_static_ag_ipv6_config() directly. | f336202:c0:m7 |
def _get_receive(self): | return self.__receive<EOL> | Getter method for receive, mapped from YANG variable /routing_system/ipv6/receive (container) | f336202:c0:m9 |
def _set_receive(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=receive.receive, 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.__receive = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for receive, mapped from YANG variable /routing_system/ipv6/receive (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_receive is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_receive() directly. | f336202:c0:m10 |
def _get_anycast_gateway_mac(self): | return self.__anycast_gateway_mac<EOL> | Getter method for anycast_gateway_mac, mapped from YANG variable /routing_system/ipv6/static_ag_ipv6_config/anycast_gateway_mac (container)
YANG Description: Anycast gateway MAC address. | f336203:c0:m3 |
def _set_anycast_gateway_mac(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=anycast_gateway_mac.anycast_gateway_mac, 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.__anycast_gateway_mac = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for anycast_gateway_mac, mapped from YANG variable /routing_system/ipv6/static_ag_ipv6_config/anycast_gateway_mac (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_anycast_gateway_mac is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_anycast_gateway_mac() directly.
YANG Description: Anycast gateway MAC address. | f336203:c0:m4 |
def _get_ipv6_anycast_gateway_mac(self): | return self.__ipv6_anycast_gateway_mac<EOL> | Getter method for ipv6_anycast_gateway_mac, mapped from YANG variable /routing_system/ipv6/static_ag_ipv6_config/anycast_gateway_mac/ipv6_anycast_gateway_mac (mac-access-list:mac-address-type) | f336204:c0:m3 |
def _set_ipv6_anycast_gateway_mac(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, extensions={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.__ipv6_anycast_gateway_mac = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ipv6_anycast_gateway_mac, mapped from YANG variable /routing_system/ipv6/static_ag_ipv6_config/anycast_gateway_mac/ipv6_anycast_gateway_mac (mac-access-list:mac-address-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_ipv6_anycast_gateway_mac is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ipv6_anycast_gateway_mac() directly. | f336204:c0:m4 |
def _get_ipv6_anycast_default_mac(self): | return self.__ipv6_anycast_default_mac<EOL> | Getter method for ipv6_anycast_default_mac, mapped from YANG variable /routing_system/ipv6/static_ag_ipv6_config/anycast_gateway_mac/ipv6_anycast_default_mac (empty)
YANG Description: Anycast gateway default MAC. | f336204:c0:m6 |
def _set_ipv6_anycast_default_mac(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>': 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.__ipv6_anycast_default_mac = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ipv6_anycast_default_mac, mapped from YANG variable /routing_system/ipv6/static_ag_ipv6_config/anycast_gateway_mac/ipv6_anycast_default_mac (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_ipv6_anycast_default_mac is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ipv6_anycast_default_mac() directly.
YANG Description: Anycast gateway default MAC. | f336204:c0:m7 |
def _get_link_interval_properties(self): | return self.__link_interval_properties<EOL> | Getter method for link_interval_properties, mapped from YANG variable /routing_system/ipv6/router/ospf/area/virtual_link/link_properties/link_interval_properties (container) | f336205:c0:m3 |
def _set_link_interval_properties(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=link_interval_properties.link_interval_properties, 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>': 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.__link_interval_properties = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for link_interval_properties, mapped from YANG variable /routing_system/ipv6/router/ospf/area/virtual_link/link_properties/link_interval_properties (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_link_interval_properties is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_link_interval_properties() directly. | f336205:c0:m4 |
def _get_authentication(self): | return self.__authentication<EOL> | Getter method for authentication, mapped from YANG variable /routing_system/ipv6/router/ospf/area/virtual_link/link_properties/authentication (container)
YANG Description: Authentication of OSPF messages | f336205:c0:m6 |
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/ipv6/router/ospf/area/virtual_link/link_properties/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 | f336205:c0:m7 |
def _get_key_chain(self): | return self.__key_chain<EOL> | Getter method for key_chain, mapped from YANG variable /routing_system/ipv6/router/ospf/area/virtual_link/link_properties/authentication/key_chain (string) | f336206: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=unicode, default=unicode("<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: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.__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/ipv6/router/ospf/area/virtual_link/link_properties/authentication/key_chain (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. | f336206:c0:m4 |
def _get_ipsec_auth_key_config(self): | return self.__ipsec_auth_key_config<EOL> | Getter method for ipsec_auth_key_config, mapped from YANG variable /routing_system/ipv6/router/ospf/area/virtual_link/link_properties/authentication/ipsec_auth_key_config (container) | f336206:c0:m6 |
def _set_ipsec_auth_key_config(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=ipsec_auth_key_config.ipsec_auth_key_config, 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>': None, u'<STR_LIT>': None, 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.__ipsec_auth_key_config = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ipsec_auth_key_config, mapped from YANG variable /routing_system/ipv6/router/ospf/area/virtual_link/link_properties/authentication/ipsec_auth_key_config (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_ipsec_auth_key_config is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ipsec_auth_key_config() directly. | f336206:c0:m7 |
def _get_vrf(self): | return self.__vrf<EOL> | Getter method for vrf, mapped from YANG variable /routing_system/ipv6/router/ospf/vrf (common-def:vrf-name)
YANG Description: OSPF instance for the VRF | f336207: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>', '<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>', 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 = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vrf, mapped from YANG variable /routing_system/ipv6/router/ospf/vrf (common-def:vrf-name)
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.
YANG Description: OSPF instance for the VRF | f336207:c0:m4 |
def _get_area(self): | return self.__area<EOL> | Getter method for area, mapped from YANG variable /routing_system/ipv6/router/ospf/area (list)
YANG Description: Set the OSPF router area id | f336207:c0:m6 |
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>': 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>': 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/ipv6/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.
YANG Description: Set the OSPF router area id | f336207:c0:m7 |
def _get_auto_cost(self): | return self.__auto_cost<EOL> | Getter method for auto_cost, mapped from YANG variable /routing_system/ipv6/router/ospf/auto_cost (container)
YANG Description: Calculate OSPFv3 interface cost according to bandwidth | f336207:c0:m9 |
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/ipv6/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.
YANG Description: Calculate OSPFv3 interface cost according to bandwidth | f336207:c0:m10 |
def _get_database_overflow_interval(self): | return self.__database_overflow_interval<EOL> | Getter method for database_overflow_interval, mapped from YANG variable /routing_system/ipv6/router/ospf/database_overflow_interval (common-def:time-interval-sec)
YANG Description: Set how often the router checks whether OSPF external LSDB overflow is eliminated. If a database overflow condition occurs on the device, the device eliminates the condition by removing entries that originated on the device. The exit overflow interval allows you to set how often a device checks to see if the overflow condition has been eliminated. If the configured value of the database overflow interval is 0, then the device never leaves the database overflow condition. | f336207:c0:m12 |
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/ipv6/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.
YANG Description: Set how often the router checks whether OSPF external LSDB overflow is eliminated. If a database overflow condition occurs on the device, the device eliminates the condition by removing entries that originated on the device. The exit overflow interval allows you to set how often a device checks to see if the overflow condition has been eliminated. If the configured value of the database overflow interval is 0, then the device never leaves the database overflow condition. | f336207:c0:m13 |
def _get_global_default_information_originate(self): | return self.__global_default_information_originate<EOL> | Getter method for global_default_information_originate, mapped from YANG variable /routing_system/ipv6/router/ospf/global_default_information_originate (container)
YANG Description: Control distribution of default information | f336207:c0:m15 |
def _set_global_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=global_default_information_originate.global_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>', 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.__global_default_information_originate = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for global_default_information_originate, mapped from YANG variable /routing_system/ipv6/router/ospf/global_default_information_originate (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_global_default_information_originate is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_global_default_information_originate() directly.
YANG Description: Control distribution of default information | f336207:c0:m16 |
def _get_default_metric(self): | return self.__default_metric<EOL> | Getter method for default_metric, mapped from YANG variable /routing_system/ipv6/router/ospf/default_metric (uint32)
YANG Description: The default metric is a global parameter that specifies the cost applied by default to routesredistributed into OSPFv3. The default value is 0. | f336207:c0:m18 |
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/ipv6/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.
YANG Description: The default metric is a global parameter that specifies the cost applied by default to routesredistributed into OSPFv3. The default value is 0. | f336207:c0:m19 |
def _get_default_passive_interface(self): | return self.__default_passive_interface<EOL> | Getter method for default_passive_interface, mapped from YANG variable /routing_system/ipv6/router/ospf/default_passive_interface (empty)
YANG Description: To set all the interfaces to the default passive state. When the interfaces are configured as passivethe interfaces drop all the OSPFv3 control packets | f336207:c0:m21 |
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/ipv6/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.
YANG Description: To set all the interfaces to the default passive state. When the interfaces are configured as passivethe interfaces drop all the OSPFv3 control packets | f336207:c0:m22 |
def _get_distance(self): | return self.__distance<EOL> | Getter method for distance, mapped from YANG variable /routing_system/ipv6/router/ospf/distance (list)
YANG Description: A unique administrative distance can be configured for each type of OSPFv3 route. This can be used to influence the device to prefer a static route over an OSPF inter-area route and to prefer OSPF intra-area routes to static routes.The distance specified influences the choice of routes when the device has multiple routes to the same network from different protocols. The device prefers the route with the lower administrative distance. | f336207:c0:m24 |
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>': 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>': 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/ipv6/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.
YANG Description: A unique administrative distance can be configured for each type of OSPFv3 route. This can be used to influence the device to prefer a static route over an OSPF inter-area route and to prefer OSPF intra-area routes to static routes.The distance specified influences the choice of routes when the device has multiple routes to the same network from different protocols. The device prefers the route with the lower administrative distance. | f336207:c0:m25 |
def _get_distribute_list(self): | return self.__distribute_list<EOL> | Getter method for distribute_list, mapped from YANG variable /routing_system/ipv6/router/ospf/distribute_list (container)
YANG Description: By configuring distribution lists we can filter the routes to be placed in the OSPFv3 route table.OSPFv3 distribution lists can filter routes using information specified in an IPv6 prefix list or a route map.Filtering using route maps has higher priority over filtering using global prefix lists. | f336207:c0:m27 |
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/ipv6/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.
YANG Description: By configuring distribution lists we can filter the routes to be placed in the OSPFv3 route table.OSPFv3 distribution lists can filter routes using information specified in an IPv6 prefix list or a route map.Filtering using route maps has higher priority over filtering using global prefix lists. | f336207:c0:m28 |
def _get_external_lsdb_limit(self): | return self.__external_lsdb_limit<EOL> | Getter method for external_lsdb_limit, mapped from YANG variable /routing_system/ipv6/router/ospf/external_lsdb_limit (uint32)
YANG Description: Set maximum number of external LSAs | f336207:c0:m30 |
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/ipv6/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.
YANG Description: Set maximum number of external LSAs | f336207:c0:m31 |
def _get_graceful_restart(self): | return self.__graceful_restart<EOL> | Getter method for graceful_restart, mapped from YANG variable /routing_system/ipv6/router/ospf/graceful_restart (container)
YANG Description: Configure OSPFv3 graceful restart options | f336207:c0:m33 |
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/ipv6/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: Configure OSPFv3 graceful restart options | f336207:c0:m34 |
def _get_key_add_remove_interval(self): | return self.__key_add_remove_interval<EOL> | Getter method for key_add_remove_interval, mapped from YANG variable /routing_system/ipv6/router/ospf/key_add_remove_interval (common-def:time-interval-sec)
YANG Description: Used to determine the interval time when authentication addition and deletion will take effect | f336207:c0:m36 |
def _set_key_add_remove_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.__key_add_remove_interval = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for key_add_remove_interval, mapped from YANG variable /routing_system/ipv6/router/ospf/key_add_remove_interval (common-def:time-interval-sec)
If this variable is read-only (config: false) in the
source YANG file, then _set_key_add_remove_interval is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_key_add_remove_interval() directly.
YANG Description: Used to determine the interval time when authentication addition and deletion will take effect | f336207:c0:m37 |
def _get_key_rollover_interval(self): | return self.__key_rollover_interval<EOL> | Getter method for key_rollover_interval, mapped from YANG variable /routing_system/ipv6/router/ospf/key_rollover_interval (common-def:time-interval-sec)
YANG Description: Configure OSPFv3 authentication key rollover interval | f336207:c0:m39 |
def _set_key_rollover_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.__key_rollover_interval = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for key_rollover_interval, mapped from YANG variable /routing_system/ipv6/router/ospf/key_rollover_interval (common-def:time-interval-sec)
If this variable is read-only (config: false) in the
source YANG file, then _set_key_rollover_interval is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_key_rollover_interval() directly.
YANG Description: Configure OSPFv3 authentication key rollover interval | f336207:c0:m40 |
def _get_log_status_change(self): | return self.__log_status_change<EOL> | Getter method for log_status_change, mapped from YANG variable /routing_system/ipv6/router/ospf/log_status_change (empty)
YANG Description: Control the logging of events related to OSPFv3, such as neighbor state changes and database overflow conditions | f336207:c0:m42 |
def _set_log_status_change(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>': 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_status_change = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for log_status_change, mapped from YANG variable /routing_system/ipv6/router/ospf/log_status_change (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_log_status_change is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_log_status_change() directly.
YANG Description: Control the logging of events related to OSPFv3, such as neighbor state changes and database overflow conditions | f336207:c0:m43 |
def _get_log(self): | return self.__log<EOL> | Getter method for log, mapped from YANG variable /routing_system/ipv6/router/ospf/log (container) | f336207:c0:m45 |
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/ipv6/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. | f336207:c0:m46 |
def _get_global_metric_type(self): | return self.__global_metric_type<EOL> | Getter method for global_metric_type, mapped from YANG variable /routing_system/ipv6/router/ospf/global_metric_type (ospf:metric-type)
YANG Description: OSPFv3 metric type for redistributed routes | f336207:c0:m48 |
def _set_global_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.__global_metric_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for global_metric_type, mapped from YANG variable /routing_system/ipv6/router/ospf/global_metric_type (ospf:metric-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_global_metric_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_global_metric_type() directly.
YANG Description: OSPFv3 metric type for redistributed routes | f336207:c0:m49 |
def _get_redistribute(self): | return self.__redistribute<EOL> | Getter method for redistribute, mapped from YANG variable /routing_system/ipv6/router/ospf/redistribute (container)
YANG Description: Enable route redistribution | f336207:c0:m51 |
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/ipv6/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.
YANG Description: Enable route redistribution | f336207:c0:m52 |
def _get_summary_address(self): | return self.__summary_address<EOL> | Getter method for summary_address, mapped from YANG variable /routing_system/ipv6/router/ospf/summary_address (list)
YANG Description: When the device is an OSPF Autonomous System Boundary Router (ASBR), you can configure it to advertise one external route as an aggregate for all redistributed routes that are covered by a specified IPv6 address range. When you configure an address range, the range takes effect immediately.All the imported routes are summarized according to the configured address range. Imported routes that have already been advertised and that fall within the range are flushed out of the AS and a single route corresponding to the range is advertised.If you use redistribution filters in addition to address ranges,the device applies the redistribution filters to routes first, then applies them to the address ranges. | f336207: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/ipv6/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.
YANG Description: When the device is an OSPF Autonomous System Boundary Router (ASBR), you can configure it to advertise one external route as an aggregate for all redistributed routes that are covered by a specified IPv6 address range. When you configure an address range, the range takes effect immediately.All the imported routes are summarized according to the configured address range. Imported routes that have already been advertised and that fall within the range are flushed out of the AS and a single route corresponding to the range is advertised.If you use redistribution filters in addition to address ranges,the device applies the redistribution filters to routes first, then applies them to the address ranges. | f336207:c0:m55 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.