Datasets:
semeru
/
code-code-MethodGeneration

Dataset card Data Studio Files
xet
 Community
signature
stringlengths
8
3.44k
body
stringlengths
0
1.41M
docstring
stringlengths
1
122k
id
stringlengths
5
17
def _get_predefined(self):
return self.__predefined<EOL>
Getter method for predefined, mapped from YANG variable /hardware/profile/tcam/predefined (container)
f336335:c0:m3
def _set_predefined(self, v, load=False):
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=predefined.predefined, 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.__predefined = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
Setter method for predefined, mapped from YANG variable /hardware/profile/tcam/predefined (container) If this variable is read-only (config: false) in the source YANG file, then _set_predefined is considered as a private method. Backends looking to populate this variable should do so via calling thisObj._set_predefined() directly.
f336335:c0:m4
def _get_cam_share(self):
return self.__cam_share<EOL>
Getter method for cam_share, mapped from YANG variable /hardware/profile/tcam/cam_share (container)
f336335:c0:m6
def _set_cam_share(self, v, load=False):
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=cam_share.cam_share, 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.__cam_share = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
Setter method for cam_share, mapped from YANG variable /hardware/profile/tcam/cam_share (container) If this variable is read-only (config: false) in the source YANG file, then _set_cam_share is considered as a private method. Backends looking to populate this variable should do so via calling thisObj._set_cam_share() directly.
f336335:c0:m7
def _get_limit(self):
return self.__limit<EOL>
Getter method for limit, mapped from YANG variable /hardware/profile/tcam/limit (container)
f336335:c0:m9
def _set_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=limit.limit, 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.__limit = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
Setter method for limit, mapped from YANG variable /hardware/profile/tcam/limit (container) If this variable is read-only (config: false) in the source YANG file, then _set_limit is considered as a private method. Backends looking to populate this variable should do so via calling thisObj._set_limit() directly.
f336335:c0:m10
def _get_l2l3v4_app(self):
return self.__l2l3v4_app<EOL>
Getter method for l2l3v4_app, mapped from YANG variable /hardware/profile/tcam/limit/l2l3v4_app (uint32)
f336336:c0:m3
def _set_l2l3v4_app(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.__l2l3v4_app = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
Setter method for l2l3v4_app, mapped from YANG variable /hardware/profile/tcam/limit/l2l3v4_app (uint32) If this variable is read-only (config: false) in the source YANG file, then _set_l2l3v4_app is considered as a private method. Backends looking to populate this variable should do so via calling thisObj._set_l2l3v4_app() directly.
f336336:c0:m4
def _get_v6_app(self):
return self.__v6_app<EOL>
Getter method for v6_app, mapped from YANG variable /hardware/profile/tcam/limit/v6_app (uint32)
f336336:c0:m6
def _set_v6_app(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.__v6_app = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
Setter method for v6_app, mapped from YANG variable /hardware/profile/tcam/limit/v6_app (uint32) If this variable is read-only (config: false) in the source YANG file, then _set_v6_app is considered as a private method. Backends looking to populate this variable should do so via calling thisObj._set_v6_app() directly.
f336336:c0:m7
def _get_flex_acl(self):
return self.__flex_acl<EOL>
Getter method for flex_acl, mapped from YANG variable /hardware/profile/tcam/limit/flex_acl (uint32)
f336336:c0:m9
def _set_flex_acl(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.__flex_acl = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
Setter method for flex_acl, mapped from YANG variable /hardware/profile/tcam/limit/flex_acl (uint32) If this variable is read-only (config: false) in the source YANG file, then _set_flex_acl is considered as a private method. Backends looking to populate this variable should do so via calling thisObj._set_flex_acl() directly.
f336336:c0:m10
def _get_connector(self):
return self.__connector<EOL>
Getter method for connector, mapped from YANG variable /hardware/connector (list)
f336337:c0:m3
def _set_connector(self, v, load=False):
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGListType("<STR_LIT:name>",connector.connector, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT:name>', extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}), is_container='<STR_LIT:list>', yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', 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.__connector = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
Setter method for connector, mapped from YANG variable /hardware/connector (list) If this variable is read-only (config: false) in the source YANG file, then _set_connector is considered as a private method. Backends looking to populate this variable should do so via calling thisObj._set_connector() directly.
f336337:c0:m4
def _get_port_group(self):
return self.__port_group<EOL>
Getter method for port_group, mapped from YANG variable /hardware/port_group (list)
f336337:c0:m6
def _set_port_group(self, v, load=False):
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGListType("<STR_LIT:name>",port_group.port_group, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT:name>', extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}), is_container='<STR_LIT:list>', yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': 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.__port_group = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
Setter method for port_group, mapped from YANG variable /hardware/port_group (list) If this variable is read-only (config: false) in the source YANG file, then _set_port_group is considered as a private method. Backends looking to populate this variable should do so via calling thisObj._set_port_group() directly.
f336337:c0:m7
def _get_custom_profile(self):
return self.__custom_profile<EOL>
Getter method for custom_profile, mapped from YANG variable /hardware/custom_profile (container)
f336337:c0:m9
def _set_custom_profile(self, v, load=False):
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=custom_profile.custom_profile, 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.__custom_profile = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
Setter method for custom_profile, mapped from YANG variable /hardware/custom_profile (container) If this variable is read-only (config: false) in the source YANG file, then _set_custom_profile is considered as a private method. Backends looking to populate this variable should do so via calling thisObj._set_custom_profile() directly.
f336337:c0:m10
def _get_profile(self):
return self.__profile<EOL>
Getter method for profile, mapped from YANG variable /hardware/profile (container)
f336337:c0:m12
def _set_profile(self, v, load=False):
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=profile.profile, 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.__profile = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
Setter method for profile, mapped from YANG variable /hardware/profile (container) If this variable is read-only (config: false) in the source YANG file, then _set_profile is considered as a private method. Backends looking to populate this variable should do so via calling thisObj._set_profile() directly.
f336337:c0:m13
def _get_map_(self):
return self.__map_<EOL>
Getter method for map_, mapped from YANG variable /qos_mpls/map (container)
f336338:c0:m3
def _set_map_(self, v, load=False):
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=map_.map_, 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.__map_ = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
Setter method for map_, mapped from YANG variable /qos_mpls/map (container) If this variable is read-only (config: false) in the source YANG file, then _set_map_ is considered as a private method. Backends looking to populate this variable should do so via calling thisObj._set_map_() directly.
f336338:c0:m4
def _get_map_apply(self):
return self.__map_apply<EOL>
Getter method for map_apply, mapped from YANG variable /qos_mpls/map_apply (container)
f336338:c0:m6
def _set_map_apply(self, v, load=False):
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=map_apply.map_apply, 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>': 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.__map_apply = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
Setter method for map_apply, mapped from YANG variable /qos_mpls/map_apply (container) If this variable is read-only (config: false) in the source YANG file, then _set_map_apply is considered as a private method. Backends looking to populate this variable should do so via calling thisObj._set_map_apply() directly.
f336338:c0:m7
def _get_bfd_static_route_dest(self):
return self.__bfd_static_route_dest<EOL>
Getter method for bfd_static_route_dest, mapped from YANG variable /vrf/address_family/ip/unicast/ip/route/static/bfd/bfd_static_route/bfd_static_route_dest (inet:ipv4-address)
f336339:c0:m3
def _set_bfd_static_route_dest(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:info>': 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.__bfd_static_route_dest = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
Setter method for bfd_static_route_dest, mapped from YANG variable /vrf/address_family/ip/unicast/ip/route/static/bfd/bfd_static_route/bfd_static_route_dest (inet:ipv4-address) If this variable is read-only (config: false) in the source YANG file, then _set_bfd_static_route_dest is considered as a private method. Backends looking to populate this variable should do so via calling thisObj._set_bfd_static_route_dest() directly.
f336339:c0:m4
def _get_bfd_static_route_src(self):
return self.__bfd_static_route_src<EOL>
Getter method for bfd_static_route_src, mapped from YANG variable /vrf/address_family/ip/unicast/ip/route/static/bfd/bfd_static_route/bfd_static_route_src (inet:ipv4-address)
f336339:c0:m6
def _set_bfd_static_route_src(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:info>': 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.__bfd_static_route_src = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
Setter method for bfd_static_route_src, mapped from YANG variable /vrf/address_family/ip/unicast/ip/route/static/bfd/bfd_static_route/bfd_static_route_src (inet:ipv4-address) If this variable is read-only (config: false) in the source YANG file, then _set_bfd_static_route_src is considered as a private method. Backends looking to populate this variable should do so via calling thisObj._set_bfd_static_route_src() directly.
f336339:c0:m7
def _get_bfd_interval_attributes(self):
return self.__bfd_interval_attributes<EOL>
Getter method for bfd_interval_attributes, mapped from YANG variable /vrf/address_family/ip/unicast/ip/route/static/bfd/bfd_static_route/bfd_interval_attributes (container)
f336339:c0:m9
def _set_bfd_interval_attributes(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_interval_attributes.bfd_interval_attributes, 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.__bfd_interval_attributes = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
Setter method for bfd_interval_attributes, mapped from YANG variable /vrf/address_family/ip/unicast/ip/route/static/bfd/bfd_static_route/bfd_interval_attributes (container) If this variable is read-only (config: false) in the source YANG file, then _set_bfd_interval_attributes is considered as a private method. Backends looking to populate this variable should do so via calling thisObj._set_bfd_interval_attributes() directly.
f336339:c0:m10
def _get_static_route_nh(self):
return self.__static_route_nh<EOL>
Getter method for static_route_nh, mapped from YANG variable /vrf/address_family/ip/unicast/ip/route/static_route_nh (list)
f336340:c0:m3
def _set_static_route_nh(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>",static_route_nh.static_route_nh, 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.__static_route_nh = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
Setter method for static_route_nh, mapped from YANG variable /vrf/address_family/ip/unicast/ip/route/static_route_nh (list) If this variable is read-only (config: false) in the source YANG file, then _set_static_route_nh is considered as a private method. Backends looking to populate this variable should do so via calling thisObj._set_static_route_nh() directly.
f336340:c0:m4
def _get_static_route_nh_vrf(self):
return self.__static_route_nh_vrf<EOL>
Getter method for static_route_nh_vrf, mapped from YANG variable /vrf/address_family/ip/unicast/ip/route/static_route_nh_vrf (list)
f336340:c0:m6
def _set_static_route_nh_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>",static_route_nh_vrf.static_route_nh_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>': 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.__static_route_nh_vrf = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
Setter method for static_route_nh_vrf, mapped from YANG variable /vrf/address_family/ip/unicast/ip/route/static_route_nh_vrf (list) If this variable is read-only (config: false) in the source YANG file, then _set_static_route_nh_vrf is considered as a private method. Backends looking to populate this variable should do so via calling thisObj._set_static_route_nh_vrf() directly.
f336340:c0:m7
def _get_static_route_oif_vrf(self):
return self.__static_route_oif_vrf<EOL>
Getter method for static_route_oif_vrf, mapped from YANG variable /vrf/address_family/ip/unicast/ip/route/static_route_oif_vrf (list)
f336340:c0:m9
def _set_static_route_oif_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>",static_route_oif_vrf.static_route_oif_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>': 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.__static_route_oif_vrf = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
Setter method for static_route_oif_vrf, mapped from YANG variable /vrf/address_family/ip/unicast/ip/route/static_route_oif_vrf (list) If this variable is read-only (config: false) in the source YANG file, then _set_static_route_oif_vrf is considered as a private method. Backends looking to populate this variable should do so via calling thisObj._set_static_route_oif_vrf() directly.
f336340:c0:m10
def _get_static_route_oif(self):
return self.__static_route_oif<EOL>
Getter method for static_route_oif, mapped from YANG variable /vrf/address_family/ip/unicast/ip/route/static_route_oif (list)
f336340:c0:m12
def _set_static_route_oif(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>",static_route_oif.static_route_oif, 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.__static_route_oif = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
Setter method for static_route_oif, mapped from YANG variable /vrf/address_family/ip/unicast/ip/route/static_route_oif (list) If this variable is read-only (config: false) in the source YANG file, then _set_static_route_oif is considered as a private method. Backends looking to populate this variable should do so via calling thisObj._set_static_route_oif() directly.
f336340:c0:m13
def _get_static(self):
return self.__static<EOL>
Getter method for static, mapped from YANG variable /vrf/address_family/ip/unicast/ip/route/static (container)
f336340:c0:m15
def _set_static(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.static, 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.__static = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
Setter method for static, mapped from YANG variable /vrf/address_family/ip/unicast/ip/route/static (container) If this variable is read-only (config: false) in the source YANG file, then _set_static is considered as a private method. Backends looking to populate this variable should do so via calling thisObj._set_static() directly.
f336340:c0:m16
def _get_max_route(self):
return self.__max_route<EOL>
Getter method for max_route, mapped from YANG variable /vrf/address_family/ip/unicast/max_route (uint32) YANG Description: Maximum number of routes allowed in this routing table
f336341:c0:m3
def _set_max_route(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.__max_route = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
Setter method for max_route, mapped from YANG variable /vrf/address_family/ip/unicast/max_route (uint32) If this variable is read-only (config: false) in the source YANG file, then _set_max_route is considered as a private method. Backends looking to populate this variable should do so via calling thisObj._set_max_route() directly. YANG Description: Maximum number of routes allowed in this routing table
f336341:c0:m4
def _get_route_target(self):
return self.__route_target<EOL>
Getter method for route_target, mapped from YANG variable /vrf/address_family/ip/unicast/route_target (list)
f336341:c0:m6
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=YANGListType("<STR_LIT>",route_target.route_target, 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>': 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>': 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.__route_target = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
Setter method for route_target, mapped from YANG variable /vrf/address_family/ip/unicast/route_target (list) 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.
f336341:c0:m7
def _get_import_(self):
return self.__import_<EOL>
Getter method for import_, mapped from YANG variable /vrf/address_family/ip/unicast/import (container)
f336341:c0:m9
def _set_import_(self, v, load=False):
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=import_.import_, 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.__import_ = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
Setter method for import_, mapped from YANG variable /vrf/address_family/ip/unicast/import (container) If this variable is read-only (config: false) in the source YANG file, then _set_import_ is considered as a private method. Backends looking to populate this variable should do so via calling thisObj._set_import_() directly.
f336341:c0:m10
def _get_export(self):
return self.__export<EOL>
Getter method for export, mapped from YANG variable /vrf/address_family/ip/unicast/export (container)
f336341:c0:m12
def _set_export(self, v, load=False):
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=export.export, 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.__export = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
Setter method for export, mapped from YANG variable /vrf/address_family/ip/unicast/export (container) If this variable is read-only (config: false) in the source YANG file, then _set_export is considered as a private method. Backends looking to populate this variable should do so via calling thisObj._set_export() directly.
f336341:c0:m13
def _get_arp_entry(self):
return self.__arp_entry<EOL>
Getter method for arp_entry, mapped from YANG variable /vrf/address_family/ip/unicast/arp_entry (list)
f336341:c0:m15
def _set_arp_entry(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>",arp_entry.arp_entry, 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>': 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>': None, 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.__arp_entry = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
Setter method for arp_entry, mapped from YANG variable /vrf/address_family/ip/unicast/arp_entry (list) If this variable is read-only (config: false) in the source YANG file, then _set_arp_entry is considered as a private method. Backends looking to populate this variable should do so via calling thisObj._set_arp_entry() directly.
f336341:c0:m16
def _get_ip(self):
return self.__ip<EOL>
Getter method for ip, mapped from YANG variable /vrf/address_family/ip/unicast/ip (container) YANG Description: rtm commands
f336341:c0:m18
def _set_ip(self, v, load=False):
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=ip.ip, 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.__ip = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
Setter method for ip, mapped from YANG variable /vrf/address_family/ip/unicast/ip (container) If this variable is read-only (config: false) in the source YANG file, then _set_ip is considered as a private method. Backends looking to populate this variable should do so via calling thisObj._set_ip() directly. YANG Description: rtm commands
f336341:c0:m19
def _get_action(self):
return self.__action<EOL>
Getter method for action, mapped from YANG variable /vrf/address_family/ip/unicast/route_target/action (enumeration)
f336342:c0:m3
def _set_action(self, v, load=False):
parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:0>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}},), is_leaf=True, yang_name="<STR_LIT:action>", rest_name="<STR_LIT:action>", 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.__action = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
Setter method for action, mapped from YANG variable /vrf/address_family/ip/unicast/route_target/action (enumeration) If this variable is read-only (config: false) in the source YANG file, then _set_action is considered as a private method. Backends looking to populate this variable should do so via calling thisObj._set_action() directly.
f336342:c0:m4
def _get_target_community(self):
return self.__target_community<EOL>
Getter method for target_community, mapped from YANG variable /vrf/address_family/ip/unicast/route_target/target_community (rt-type) YANG Description: Target VPN Extended Community
f336342:c0:m6
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=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:info>': 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 /vrf/address_family/ip/unicast/route_target/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
f336342:c0:m7
def _get_evpn(self):
return self.__evpn<EOL>
Getter method for evpn, mapped from YANG variable /vrf/address_family/ip/unicast/route_target/evpn (empty)
f336342:c0:m9
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=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.__evpn = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
Setter method for evpn, mapped from YANG variable /vrf/address_family/ip/unicast/route_target/evpn (empty) 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.
f336342:c0:m10
def _get_arp_ip_address(self):
return self.__arp_ip_address<EOL>
Getter method for arp_ip_address, mapped from YANG variable /vrf/address_family/ip/unicast/arp_entry/arp_ip_address (inet:ipv4-address) YANG Description: IPv4 Address
f336343:c0:m3
def _set_arp_ip_address(self, v, load=False):
parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>'}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, 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.__arp_ip_address = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
Setter method for arp_ip_address, mapped from YANG variable /vrf/address_family/ip/unicast/arp_entry/arp_ip_address (inet:ipv4-address) If this variable is read-only (config: false) in the source YANG file, then _set_arp_ip_address is considered as a private method. Backends looking to populate this variable should do so via calling thisObj._set_arp_ip_address() directly. YANG Description: IPv4 Address
f336343:c0:m4
def _get_mac_address_value(self):
return self.__mac_address_value<EOL>
Getter method for mac_address_value, mapped from YANG variable /vrf/address_family/ip/unicast/arp_entry/mac_address_value (mac-access-list:mac-address-type)
f336343:c0:m6
def _set_mac_address_value(self, v, load=False):
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=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, 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.__mac_address_value = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
Setter method for mac_address_value, mapped from YANG variable /vrf/address_family/ip/unicast/arp_entry/mac_address_value (mac-access-list:mac-address-type) If this variable is read-only (config: false) in the source YANG file, then _set_mac_address_value is considered as a private method. Backends looking to populate this variable should do so via calling thisObj._set_mac_address_value() directly.
f336343:c0:m7
def _get_interfacename(self):
return self.__interfacename<EOL>
Getter method for interfacename, mapped from YANG variable /vrf/address_family/ip/unicast/arp_entry/interfacename (enumeration)
f336343:c0:m9
def _set_interfacename(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>': {}},), 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, 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.__interfacename = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
Setter method for interfacename, mapped from YANG variable /vrf/address_family/ip/unicast/arp_entry/interfacename (enumeration) If this variable is read-only (config: false) in the source YANG file, then _set_interfacename is considered as a private method. Backends looking to populate this variable should do so via calling thisObj._set_interfacename() directly.
f336343:c0:m10
def _get_Ethernet(self):
return self.__Ethernet<EOL>
Getter method for Ethernet, mapped from YANG variable /vrf/address_family/ip/unicast/arp_entry/Ethernet (interface:interface-type) YANG Description: Ethernet
f336343:c0:m12
def _set_Ethernet(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, choice=(u'<STR_LIT>', u'<STR_LIT>'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={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.__Ethernet = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
Setter method for Ethernet, mapped from YANG variable /vrf/address_family/ip/unicast/arp_entry/Ethernet (interface:interface-type) If this variable is read-only (config: false) in the source YANG file, then _set_Ethernet is considered as a private method. Backends looking to populate this variable should do so via calling thisObj._set_Ethernet() directly. YANG Description: Ethernet
f336343:c0:m13
def _get_Ve(self):
return self.__Ve<EOL>
Getter method for Ve, mapped from YANG variable /vrf/address_family/ip/unicast/arp_entry/Ve (interface:ve-type) YANG Description: Ve
f336343:c0:m15
def _set_Ve(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, choice=(u'<STR_LIT>', u'<STR_LIT>'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={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.__Ve = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
Setter method for Ve, mapped from YANG variable /vrf/address_family/ip/unicast/arp_entry/Ve (interface:ve-type) If this variable is read-only (config: false) in the source YANG file, then _set_Ve is considered as a private method. Backends looking to populate this variable should do so via calling thisObj._set_Ve() directly. YANG Description: Ve
f336343:c0:m16
def _get_bfd_ipv6_link_local_dest(self):
return self.__bfd_ipv6_link_local_dest<EOL>
Getter method for bfd_ipv6_link_local_dest, mapped from YANG variable /vrf/address_family/ipv6/unicast/ipv6/route/static/bfd/bfd_ipv6_link_local_static_route/bfd_ipv6_link_local_dest (inet:ipv6-address)
f336344:c0:m3
def _set_bfd_ipv6_link_local_dest(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:info>': 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.__bfd_ipv6_link_local_dest = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
Setter method for bfd_ipv6_link_local_dest, mapped from YANG variable /vrf/address_family/ipv6/unicast/ipv6/route/static/bfd/bfd_ipv6_link_local_static_route/bfd_ipv6_link_local_dest (inet:ipv6-address) If this variable is read-only (config: false) in the source YANG file, then _set_bfd_ipv6_link_local_dest is considered as a private method. Backends looking to populate this variable should do so via calling thisObj._set_bfd_ipv6_link_local_dest() directly.
f336344:c0:m4
def _get_bfd_ipv6_link_local_src(self):
return self.__bfd_ipv6_link_local_src<EOL>
Getter method for bfd_ipv6_link_local_src, mapped from YANG variable /vrf/address_family/ipv6/unicast/ipv6/route/static/bfd/bfd_ipv6_link_local_static_route/bfd_ipv6_link_local_src (inet:ipv6-address)
f336344:c0:m6
def _set_bfd_ipv6_link_local_src(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:info>': 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.__bfd_ipv6_link_local_src = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
Setter method for bfd_ipv6_link_local_src, mapped from YANG variable /vrf/address_family/ipv6/unicast/ipv6/route/static/bfd/bfd_ipv6_link_local_static_route/bfd_ipv6_link_local_src (inet:ipv6-address) If this variable is read-only (config: false) in the source YANG file, then _set_bfd_ipv6_link_local_src is considered as a private method. Backends looking to populate this variable should do so via calling thisObj._set_bfd_ipv6_link_local_src() directly.
f336344:c0:m7
def _get_bfd_interface_type(self):
return self.__bfd_interface_type<EOL>
Getter method for bfd_interface_type, mapped from YANG variable /vrf/address_family/ipv6/unicast/ipv6/route/static/bfd/bfd_ipv6_link_local_static_route/bfd_interface_type (enumeration)
f336344:c0:m9
def _set_bfd_interface_type(self, v, load=False):
parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT:null>': {'<STR_LIT:value>': <NUM_LIT:5>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:4>}},), 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>'}}, 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.__bfd_interface_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
Setter method for bfd_interface_type, mapped from YANG variable /vrf/address_family/ipv6/unicast/ipv6/route/static/bfd/bfd_ipv6_link_local_static_route/bfd_interface_type (enumeration) If this variable is read-only (config: false) in the source YANG file, then _set_bfd_interface_type is considered as a private method. Backends looking to populate this variable should do so via calling thisObj._set_bfd_interface_type() directly.
f336344:c0:m10
def _get_bfd_interface_name(self):
return self.__bfd_interface_name<EOL>
Getter method for bfd_interface_name, mapped from YANG variable /vrf/address_family/ipv6/unicast/ipv6/route/static/bfd/bfd_ipv6_link_local_static_route/bfd_interface_name (string)
f336344:c0:m12
def _set_bfd_interface_name(self, v, load=False):
parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=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: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.__bfd_interface_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
Setter method for bfd_interface_name, mapped from YANG variable /vrf/address_family/ipv6/unicast/ipv6/route/static/bfd/bfd_ipv6_link_local_static_route/bfd_interface_name (string) If this variable is read-only (config: false) in the source YANG file, then _set_bfd_interface_name is considered as a private method. Backends looking to populate this variable should do so via calling thisObj._set_bfd_interface_name() directly.
f336344:c0:m13
def _get_bfd_ipv6_interval_attributes(self):
return self.__bfd_ipv6_interval_attributes<EOL>
Getter method for bfd_ipv6_interval_attributes, mapped from YANG variable /vrf/address_family/ipv6/unicast/ipv6/route/static/bfd/bfd_ipv6_link_local_static_route/bfd_ipv6_interval_attributes (container)
f336344:c0:m15
def _set_bfd_ipv6_interval_attributes(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_ipv6_interval_attributes.bfd_ipv6_interval_attributes, 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.__bfd_ipv6_interval_attributes = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
Setter method for bfd_ipv6_interval_attributes, mapped from YANG variable /vrf/address_family/ipv6/unicast/ipv6/route/static/bfd/bfd_ipv6_link_local_static_route/bfd_ipv6_interval_attributes (container) If this variable is read-only (config: false) in the source YANG file, then _set_bfd_ipv6_interval_attributes is considered as a private method. Backends looking to populate this variable should do so via calling thisObj._set_bfd_ipv6_interval_attributes() directly.
f336344:c0:m16
def _get_bfd_ipv6_static_route_dest(self):
return self.__bfd_ipv6_static_route_dest<EOL>
Getter method for bfd_ipv6_static_route_dest, mapped from YANG variable /vrf/address_family/ipv6/unicast/ipv6/route/static/bfd/bfd_ipv6_static_route/bfd_ipv6_static_route_dest (inet:ipv6-address)
f336345:c0:m3
def _set_bfd_ipv6_static_route_dest(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:info>': 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.__bfd_ipv6_static_route_dest = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
Setter method for bfd_ipv6_static_route_dest, mapped from YANG variable /vrf/address_family/ipv6/unicast/ipv6/route/static/bfd/bfd_ipv6_static_route/bfd_ipv6_static_route_dest (inet:ipv6-address) If this variable is read-only (config: false) in the source YANG file, then _set_bfd_ipv6_static_route_dest is considered as a private method. Backends looking to populate this variable should do so via calling thisObj._set_bfd_ipv6_static_route_dest() directly.
f336345:c0:m4
def _get_bfd_ipv6_static_route_src(self):
return self.__bfd_ipv6_static_route_src<EOL>
Getter method for bfd_ipv6_static_route_src, mapped from YANG variable /vrf/address_family/ipv6/unicast/ipv6/route/static/bfd/bfd_ipv6_static_route/bfd_ipv6_static_route_src (inet:ipv6-address)
f336345:c0:m6
def _set_bfd_ipv6_static_route_src(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:info>': 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.__bfd_ipv6_static_route_src = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
Setter method for bfd_ipv6_static_route_src, mapped from YANG variable /vrf/address_family/ipv6/unicast/ipv6/route/static/bfd/bfd_ipv6_static_route/bfd_ipv6_static_route_src (inet:ipv6-address) If this variable is read-only (config: false) in the source YANG file, then _set_bfd_ipv6_static_route_src is considered as a private method. Backends looking to populate this variable should do so via calling thisObj._set_bfd_ipv6_static_route_src() directly.
f336345:c0:m7
def _get_bfd_ipv6_interval_attributes(self):
return self.__bfd_ipv6_interval_attributes<EOL>
Getter method for bfd_ipv6_interval_attributes, mapped from YANG variable /vrf/address_family/ipv6/unicast/ipv6/route/static/bfd/bfd_ipv6_static_route/bfd_ipv6_interval_attributes (container)
f336345:c0:m9
def _set_bfd_ipv6_interval_attributes(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_ipv6_interval_attributes.bfd_ipv6_interval_attributes, 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.__bfd_ipv6_interval_attributes = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
Setter method for bfd_ipv6_interval_attributes, mapped from YANG variable /vrf/address_family/ipv6/unicast/ipv6/route/static/bfd/bfd_ipv6_static_route/bfd_ipv6_interval_attributes (container) If this variable is read-only (config: false) in the source YANG file, then _set_bfd_ipv6_interval_attributes is considered as a private method. Backends looking to populate this variable should do so via calling thisObj._set_bfd_ipv6_interval_attributes() directly.
f336345:c0:m10
def _get_static_route_nh(self):
return self.__static_route_nh<EOL>
Getter method for static_route_nh, mapped from YANG variable /vrf/address_family/ipv6/unicast/ipv6/route/static_route_nh (list)
f336346:c0:m3
def _set_static_route_nh(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>",static_route_nh.static_route_nh, 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.__static_route_nh = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
Setter method for static_route_nh, mapped from YANG variable /vrf/address_family/ipv6/unicast/ipv6/route/static_route_nh (list) If this variable is read-only (config: false) in the source YANG file, then _set_static_route_nh is considered as a private method. Backends looking to populate this variable should do so via calling thisObj._set_static_route_nh() directly.
f336346:c0:m4
def _get_static_route_oif(self):
return self.__static_route_oif<EOL>
Getter method for static_route_oif, mapped from YANG variable /vrf/address_family/ipv6/unicast/ipv6/route/static_route_oif (list)
f336346:c0:m6
def _set_static_route_oif(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>",static_route_oif.static_route_oif, 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.__static_route_oif = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
Setter method for static_route_oif, mapped from YANG variable /vrf/address_family/ipv6/unicast/ipv6/route/static_route_oif (list) If this variable is read-only (config: false) in the source YANG file, then _set_static_route_oif is considered as a private method. Backends looking to populate this variable should do so via calling thisObj._set_static_route_oif() directly.
f336346:c0:m7
def _get_link_local_static_route_nh(self):
return self.__link_local_static_route_nh<EOL>
Getter method for link_local_static_route_nh, mapped from YANG variable /vrf/address_family/ipv6/unicast/ipv6/route/link_local_static_route_nh (list)
f336346:c0:m9
def _set_link_local_static_route_nh(self, v, load=False):
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGListType("<STR_LIT>",link_local_static_route_nh.link_local_static_route_nh, 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.__link_local_static_route_nh = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
Setter method for link_local_static_route_nh, mapped from YANG variable /vrf/address_family/ipv6/unicast/ipv6/route/link_local_static_route_nh (list) If this variable is read-only (config: false) in the source YANG file, then _set_link_local_static_route_nh is considered as a private method. Backends looking to populate this variable should do so via calling thisObj._set_link_local_static_route_nh() directly.
f336346:c0:m10
def _get_static_route_nh_vrf(self):
return self.__static_route_nh_vrf<EOL>
Getter method for static_route_nh_vrf, mapped from YANG variable /vrf/address_family/ipv6/unicast/ipv6/route/static_route_nh_vrf (list)
f336346:c0:m12
def _set_static_route_nh_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>",static_route_nh_vrf.static_route_nh_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>': 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.__static_route_nh_vrf = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
Setter method for static_route_nh_vrf, mapped from YANG variable /vrf/address_family/ipv6/unicast/ipv6/route/static_route_nh_vrf (list) If this variable is read-only (config: false) in the source YANG file, then _set_static_route_nh_vrf is considered as a private method. Backends looking to populate this variable should do so via calling thisObj._set_static_route_nh_vrf() directly.
f336346:c0:m13
def _get_link_local_static_route_nh_vrf(self):
return self.__link_local_static_route_nh_vrf<EOL>
Getter method for link_local_static_route_nh_vrf, mapped from YANG variable /vrf/address_family/ipv6/unicast/ipv6/route/link_local_static_route_nh_vrf (list)
f336346:c0:m15
def _set_link_local_static_route_nh_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>",link_local_static_route_nh_vrf.link_local_static_route_nh_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>': 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.__link_local_static_route_nh_vrf = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
Setter method for link_local_static_route_nh_vrf, mapped from YANG variable /vrf/address_family/ipv6/unicast/ipv6/route/link_local_static_route_nh_vrf (list) If this variable is read-only (config: false) in the source YANG file, then _set_link_local_static_route_nh_vrf is considered as a private method. Backends looking to populate this variable should do so via calling thisObj._set_link_local_static_route_nh_vrf() directly.
f336346:c0:m16
def _get_ipv6_static_route_oif_vrf(self):
return self.__ipv6_static_route_oif_vrf<EOL>
Getter method for ipv6_static_route_oif_vrf, mapped from YANG variable /vrf/address_family/ipv6/unicast/ipv6/route/ipv6_static_route_oif_vrf (list)
f336346:c0:m18
def _set_ipv6_static_route_oif_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>",ipv6_static_route_oif_vrf.ipv6_static_route_oif_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>': 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.__ipv6_static_route_oif_vrf = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
Setter method for ipv6_static_route_oif_vrf, mapped from YANG variable /vrf/address_family/ipv6/unicast/ipv6/route/ipv6_static_route_oif_vrf (list) If this variable is read-only (config: false) in the source YANG file, then _set_ipv6_static_route_oif_vrf is considered as a private method. Backends looking to populate this variable should do so via calling thisObj._set_ipv6_static_route_oif_vrf() directly.
f336346:c0:m19
def _get_static(self):
return self.__static<EOL>
Getter method for static, mapped from YANG variable /vrf/address_family/ipv6/unicast/ipv6/route/static (container)
f336346:c0:m21
def _set_static(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.static, 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.__static = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
Setter method for static, mapped from YANG variable /vrf/address_family/ipv6/unicast/ipv6/route/static (container) If this variable is read-only (config: false) in the source YANG file, then _set_static is considered as a private method. Backends looking to populate this variable should do so via calling thisObj._set_static() directly.
f336346:c0:m22
def _get_max_route(self):
return self.__max_route<EOL>
Getter method for max_route, mapped from YANG variable /vrf/address_family/ipv6/unicast/max_route (uint32) YANG Description: Maximum number of routes allowed in this routing table
f336347:c0:m3
def _set_max_route(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.__max_route = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
Setter method for max_route, mapped from YANG variable /vrf/address_family/ipv6/unicast/max_route (uint32) If this variable is read-only (config: false) in the source YANG file, then _set_max_route is considered as a private method. Backends looking to populate this variable should do so via calling thisObj._set_max_route() directly. YANG Description: Maximum number of routes allowed in this routing table
f336347:c0:m4