signature stringlengths 8 3.44k | body stringlengths 0 1.41M | docstring stringlengths 1 122k | id stringlengths 5 17 |
|---|---|---|---|
def _get_include_all(self): | return self.__include_all<EOL> | Getter method for include_all, mapped from YANG variable /mpls_state/dynamic_bypass/dynamic_bypass_interface/include_all (uint32)
YANG Description: Include all admin groups | f336469:c0:m72 |
def _set_include_all(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__include_all = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for include_all, mapped from YANG variable /mpls_state/dynamic_bypass/dynamic_bypass_interface/include_all (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_include_all is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_include_all() directly.
YANG Description: Include all admin groups | f336469:c0:m73 |
def _get_include_any(self): | return self.__include_any<EOL> | Getter method for include_any, mapped from YANG variable /mpls_state/dynamic_bypass/dynamic_bypass_interface/include_any (uint32)
YANG Description: Include any admin group | f336469:c0:m75 |
def _set_include_any(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__include_any = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for include_any, mapped from YANG variable /mpls_state/dynamic_bypass/dynamic_bypass_interface/include_any (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_include_any is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_include_any() directly.
YANG Description: Include any admin group | f336469:c0:m76 |
def _get_status_flags(self): | return self.__status_flags<EOL> | Getter method for status_flags, mapped from YANG variable /mpls_state/dynamic_bypass/dynamic_bypass_interface/status_flags (uint32)
YANG Description: Status flags | f336469:c0:m78 |
def _set_status_flags(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__status_flags = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for status_flags, mapped from YANG variable /mpls_state/dynamic_bypass/dynamic_bypass_interface/status_flags (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_status_flags is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_status_flags() directly.
YANG Description: Status flags | f336469:c0:m79 |
def _get_mp_count(self): | return self.__mp_count<EOL> | Getter method for mp_count, mapped from YANG variable /mpls_state/dynamic_bypass/dynamic_bypass_interface/mp_count (uint32)
YANG Description: Count of merge points | f336469:c0:m81 |
def _set_mp_count(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__mp_count = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mp_count, mapped from YANG variable /mpls_state/dynamic_bypass/dynamic_bypass_interface/mp_count (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_mp_count is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mp_count() directly.
YANG Description: Count of merge points | f336469:c0:m82 |
def _get_mp_infos(self): | return self.__mp_infos<EOL> | Getter method for mp_infos, mapped from YANG variable /mpls_state/dynamic_bypass/dynamic_bypass_interface/mp_infos (list)
YANG Description: Merge point info | f336469:c0:m84 |
def _set_mp_infos(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>",mp_infos.mp_infos, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT>', extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}), is_container='<STR_LIT:list>', yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:list>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__mp_infos = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mp_infos, mapped from YANG variable /mpls_state/dynamic_bypass/dynamic_bypass_interface/mp_infos (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_mp_infos is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mp_infos() directly.
YANG Description: Merge point info | f336469:c0:m85 |
def _get_port(self): | return self.__port<EOL> | Getter method for port, mapped from YANG variable /tacacs_server/host/tacacs_server_options/port (tac-auth-port) | f336470:c0:m3 |
def _set_port(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']},int_size=<NUM_LIT:16>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), default=RestrictedClassType(base_type=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']},int_size=<NUM_LIT:16>)(<NUM_LIT>), is_leaf=True, yang_name="<STR_LIT:port>", rest_name="<STR_LIT:port>", 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.__port = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for port, mapped from YANG variable /tacacs_server/host/tacacs_server_options/port (tac-auth-port)
If this variable is read-only (config: false) in the
source YANG file, then _set_port is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_port() directly. | f336470:c0:m4 |
def _get_protocol(self): | return self.__protocol<EOL> | Getter method for protocol, mapped from YANG variable /tacacs_server/host/tacacs_server_options/protocol (tac-auth-protocols) | f336470:c0:m6 |
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=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>}},), 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: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 /tacacs_server/host/tacacs_server_options/protocol (tac-auth-protocols)
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. | f336470:c0:m7 |
def _get_key(self): | return self.__key<EOL> | Getter method for key, mapped from YANG variable /tacacs_server/host/tacacs_server_options/key (string) | f336470:c0:m9 |
def _set_key(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT:key>", rest_name="<STR_LIT:key>", 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: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 = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for key, mapped from YANG variable /tacacs_server/host/tacacs_server_options/key (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_key is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_key() directly. | f336470:c0:m10 |
def _get_encryption_level(self): | return self.__encryption_level<EOL> | Getter method for encryption_level, mapped from YANG variable /tacacs_server/host/tacacs_server_options/encryption_level (enumeration) | f336470:c0:m12 |
def _set_encryption_level(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:0>': {'<STR_LIT:value>': <NUM_LIT:0>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:7>}},), 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.__encryption_level = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for encryption_level, mapped from YANG variable /tacacs_server/host/tacacs_server_options/encryption_level (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_encryption_level is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_encryption_level() directly. | f336470:c0:m13 |
def _get_retries(self): | return self.__retries<EOL> | Getter method for retries, mapped from YANG variable /tacacs_server/host/tacacs_server_options/retries (uint8) | f336470:c0:m15 |
def _set_retries(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:8>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), default=RestrictedClassType(base_type=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:8>)(<NUM_LIT:5>), 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.__retries = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for retries, mapped from YANG variable /tacacs_server/host/tacacs_server_options/retries (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_retries is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_retries() directly. | f336470:c0:m16 |
def _get_timeout(self): | return self.__timeout<EOL> | Getter method for timeout, mapped from YANG variable /tacacs_server/host/tacacs_server_options/timeout (uint8) | f336470:c0:m18 |
def _set_timeout(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:8>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), default=RestrictedClassType(base_type=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:8>)(<NUM_LIT:5>), 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.__timeout = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for timeout, mapped from YANG variable /tacacs_server/host/tacacs_server_options/timeout (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_timeout is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_timeout() directly. | f336470:c0:m19 |
def _get_name(self): | return self.__name<EOL> | Getter method for name, mapped from YANG variable /brocade_vswitch_rpc/get_vnetwork_hosts/output/vnetwork_hosts/name (string)
YANG Description: host name | f336471:c0:m3 |
def _set_name(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT:name>", rest_name="<STR_LIT:name>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, 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.__name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for name, mapped from YANG variable /brocade_vswitch_rpc/get_vnetwork_hosts/output/vnetwork_hosts/name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_name() directly.
YANG Description: host name | f336471:c0:m4 |
def _get_vmnic(self): | return self.__vmnic<EOL> | Getter method for vmnic, mapped from YANG variable /brocade_vswitch_rpc/get_vnetwork_hosts/output/vnetwork_hosts/vmnic (string)
YANG Description: host NIC | f336471:c0:m6 |
def _set_vmnic(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=False, 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.__vmnic = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vmnic, mapped from YANG variable /brocade_vswitch_rpc/get_vnetwork_hosts/output/vnetwork_hosts/vmnic (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_vmnic is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vmnic() directly.
YANG Description: host NIC | f336471:c0:m7 |
def _get_datacenter(self): | return self.__datacenter<EOL> | Getter method for datacenter, mapped from YANG variable /brocade_vswitch_rpc/get_vnetwork_hosts/output/vnetwork_hosts/datacenter (string)
YANG Description: host datacenter | f336471:c0:m9 |
def _set_datacenter(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=False, 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.__datacenter = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for datacenter, mapped from YANG variable /brocade_vswitch_rpc/get_vnetwork_hosts/output/vnetwork_hosts/datacenter (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_datacenter is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_datacenter() directly.
YANG Description: host datacenter | f336471:c0:m10 |
def _get_mac(self): | return self.__mac<EOL> | Getter method for mac, mapped from YANG variable /brocade_vswitch_rpc/get_vnetwork_hosts/output/vnetwork_hosts/mac (yang:mac-address)
YANG Description: vmnic Mac address in HH:HH:HH:HH:HH:HH format | f336471:c0:m12 |
def _set_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=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=False, 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 = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mac, mapped from YANG variable /brocade_vswitch_rpc/get_vnetwork_hosts/output/vnetwork_hosts/mac (yang:mac-address)
If this variable is read-only (config: false) in the
source YANG file, then _set_mac is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mac() directly.
YANG Description: vmnic Mac address in HH:HH:HH:HH:HH:HH format | f336471:c0:m13 |
def _get_vswitch(self): | return self.__vswitch<EOL> | Getter method for vswitch, mapped from YANG variable /brocade_vswitch_rpc/get_vnetwork_hosts/output/vnetwork_hosts/vswitch (string)
YANG Description: regular or distributed virtual switch | f336471:c0:m15 |
def _set_vswitch(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=False, 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.__vswitch = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vswitch, mapped from YANG variable /brocade_vswitch_rpc/get_vnetwork_hosts/output/vnetwork_hosts/vswitch (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_vswitch is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vswitch() directly.
YANG Description: regular or distributed virtual switch | f336471:c0:m16 |
def _get_interface_type(self): | return self.__interface_type<EOL> | Getter method for interface_type, mapped from YANG variable /brocade_vswitch_rpc/get_vnetwork_hosts/output/vnetwork_hosts/interface_type (enumeration)
YANG Description: The type of the interface. An 'unknown' type
represents error scenario and should not be used. | f336471:c0:m18 |
def _set_interface_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:8>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:7>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:12>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:5>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:11>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:10>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:6>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, 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.__interface_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for interface_type, mapped from YANG variable /brocade_vswitch_rpc/get_vnetwork_hosts/output/vnetwork_hosts/interface_type (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_interface_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_interface_type() directly.
YANG Description: The type of the interface. An 'unknown' type
represents error scenario and should not be used. | f336471:c0:m19 |
def _get_interface_name(self): | return self.__interface_name<EOL> | Getter method for interface_name, mapped from YANG variable /brocade_vswitch_rpc/get_vnetwork_hosts/output/vnetwork_hosts/interface_name (union)
YANG Description: The Interface value. The interface value is always
interpreted within the context of the value of
'interface-type' leaf:
interface-type interface-name
----------------- --------------------
ethernet slot/port
port-channel Port channel ID
l2vlan Vlan ID
loopback Loopback ID
ve VE Interface ID
unknown Zero-length string.
The value of an 'interface-name' must always be
consistent with the value of the associated
'interface-type'. Attempts to set an interface-name
to a value inconsistent with the associated
'interface-type' must fail with an error. | f336471:c0:m21 |
def _set_interface_name(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=[RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>', '<STR_LIT>': [u'<STR_LIT>']}),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>']}),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=False, 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.__interface_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for interface_name, mapped from YANG variable /brocade_vswitch_rpc/get_vnetwork_hosts/output/vnetwork_hosts/interface_name (union)
If this variable is read-only (config: false) in the
source YANG file, then _set_interface_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_interface_name() directly.
YANG Description: The Interface value. The interface value is always
interpreted within the context of the value of
'interface-type' leaf:
interface-type interface-name
----------------- --------------------
ethernet slot/port
port-channel Port channel ID
l2vlan Vlan ID
loopback Loopback ID
ve VE Interface ID
unknown Zero-length string.
The value of an 'interface-name' must always be
consistent with the value of the associated
'interface-type'. Attempts to set an interface-name
to a value inconsistent with the associated
'interface-type' must fail with an error. | f336471:c0:m22 |
def _get_name(self): | return self.__name<EOL> | Getter method for name, mapped from YANG variable /brocade_vswitch_rpc/get_vnetwork_vswitches/output/vnetwork_vswitches/name (string)
YANG Description: virtual switch name | f336472:c0:m3 |
def _set_name(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT:name>", rest_name="<STR_LIT:name>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, 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.__name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for name, mapped from YANG variable /brocade_vswitch_rpc/get_vnetwork_vswitches/output/vnetwork_vswitches/name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_name() directly.
YANG Description: virtual switch name | f336472:c0:m4 |
def _get_host(self): | return self.__host<EOL> | Getter method for host, mapped from YANG variable /brocade_vswitch_rpc/get_vnetwork_vswitches/output/vnetwork_vswitches/host (string)
YANG Description: host name | f336472:c0:m6 |
def _set_host(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:host>", rest_name="<STR_LIT:host>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, 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.__host = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for host, mapped from YANG variable /brocade_vswitch_rpc/get_vnetwork_vswitches/output/vnetwork_vswitches/host (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_host is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_host() directly.
YANG Description: host name | f336472:c0:m7 |
def _get_datacenter(self): | return self.__datacenter<EOL> | Getter method for datacenter, mapped from YANG variable /brocade_vswitch_rpc/get_vnetwork_vswitches/output/vnetwork_vswitches/datacenter (string)
YANG Description: host datacenter | f336472:c0:m9 |
def _set_datacenter(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=False, 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.__datacenter = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for datacenter, mapped from YANG variable /brocade_vswitch_rpc/get_vnetwork_vswitches/output/vnetwork_vswitches/datacenter (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_datacenter is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_datacenter() directly.
YANG Description: host datacenter | f336472:c0:m10 |
def _get_pnic(self): | return self.__pnic<EOL> | Getter method for pnic, mapped from YANG variable /brocade_vswitch_rpc/get_vnetwork_vswitches/output/vnetwork_vswitches/pnic (string)
YANG Description: host NIC | f336472:c0:m12 |
def _set_pnic(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=False, 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.__pnic = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for pnic, mapped from YANG variable /brocade_vswitch_rpc/get_vnetwork_vswitches/output/vnetwork_vswitches/pnic (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_pnic is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_pnic() directly.
YANG Description: host NIC | f336472:c0:m13 |
def _get_interface_type(self): | return self.__interface_type<EOL> | Getter method for interface_type, mapped from YANG variable /brocade_vswitch_rpc/get_vnetwork_vswitches/output/vnetwork_vswitches/interface_type (enumeration)
YANG Description: The type of the interface. An 'unknown' type
represents error scenario and should not be used. | f336472:c0:m15 |
def _set_interface_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:8>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:7>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:12>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:5>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:11>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:10>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:6>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, 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.__interface_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for interface_type, mapped from YANG variable /brocade_vswitch_rpc/get_vnetwork_vswitches/output/vnetwork_vswitches/interface_type (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_interface_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_interface_type() directly.
YANG Description: The type of the interface. An 'unknown' type
represents error scenario and should not be used. | f336472:c0:m16 |
def _get_interface_name(self): | return self.__interface_name<EOL> | Getter method for interface_name, mapped from YANG variable /brocade_vswitch_rpc/get_vnetwork_vswitches/output/vnetwork_vswitches/interface_name (union)
YANG Description: The Interface value. The interface value is always
interpreted within the context of the value of
'interface-type' leaf:
interface-type interface-name
----------------- --------------------
ethernet slot/port
port-channel Port channel ID
l2vlan Vlan ID
loopback Loopback ID
ve VE Interface ID
unknown Zero-length string.
The value of an 'interface-name' must always be
consistent with the value of the associated
'interface-type'. Attempts to set an interface-name
to a value inconsistent with the associated
'interface-type' must fail with an error. | f336472:c0:m18 |
def _set_interface_name(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=[RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>', '<STR_LIT>': [u'<STR_LIT>']}),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>']}),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=False, 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.__interface_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for interface_name, mapped from YANG variable /brocade_vswitch_rpc/get_vnetwork_vswitches/output/vnetwork_vswitches/interface_name (union)
If this variable is read-only (config: false) in the
source YANG file, then _set_interface_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_interface_name() directly.
YANG Description: The Interface value. The interface value is always
interpreted within the context of the value of
'interface-type' leaf:
interface-type interface-name
----------------- --------------------
ethernet slot/port
port-channel Port channel ID
l2vlan Vlan ID
loopback Loopback ID
ve VE Interface ID
unknown Zero-length string.
The value of an 'interface-name' must always be
consistent with the value of the associated
'interface-type'. Attempts to set an interface-name
to a value inconsistent with the associated
'interface-type' must fail with an error. | f336472:c0:m19 |
def _get_name(self): | return self.__name<EOL> | Getter method for name, mapped from YANG variable /brocade_vswitch_rpc/get_vnetwork_dvs/output/vnetwork_dvs/name (string)
YANG Description: distributed virtual switch name | f336473:c0:m3 |
def _set_name(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT:name>", rest_name="<STR_LIT:name>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, 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.__name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for name, mapped from YANG variable /brocade_vswitch_rpc/get_vnetwork_dvs/output/vnetwork_dvs/name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_name() directly.
YANG Description: distributed virtual switch name | f336473:c0:m4 |
def _get_host(self): | return self.__host<EOL> | Getter method for host, mapped from YANG variable /brocade_vswitch_rpc/get_vnetwork_dvs/output/vnetwork_dvs/host (string)
YANG Description: host name | f336473:c0:m6 |
def _set_host(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:host>", rest_name="<STR_LIT:host>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, 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.__host = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for host, mapped from YANG variable /brocade_vswitch_rpc/get_vnetwork_dvs/output/vnetwork_dvs/host (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_host is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_host() directly.
YANG Description: host name | f336473:c0:m7 |
def _get_datacenter(self): | return self.__datacenter<EOL> | Getter method for datacenter, mapped from YANG variable /brocade_vswitch_rpc/get_vnetwork_dvs/output/vnetwork_dvs/datacenter (string)
YANG Description: host datacenter | f336473:c0:m9 |
def _set_datacenter(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=False, 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.__datacenter = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for datacenter, mapped from YANG variable /brocade_vswitch_rpc/get_vnetwork_dvs/output/vnetwork_dvs/datacenter (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_datacenter is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_datacenter() directly.
YANG Description: host datacenter | f336473:c0:m10 |
def _get_pnic(self): | return self.__pnic<EOL> | Getter method for pnic, mapped from YANG variable /brocade_vswitch_rpc/get_vnetwork_dvs/output/vnetwork_dvs/pnic (string)
YANG Description: host NIC | f336473:c0:m12 |
def _set_pnic(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=False, 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.__pnic = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for pnic, mapped from YANG variable /brocade_vswitch_rpc/get_vnetwork_dvs/output/vnetwork_dvs/pnic (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_pnic is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_pnic() directly.
YANG Description: host NIC | f336473:c0:m13 |
def _get_interface_type(self): | return self.__interface_type<EOL> | Getter method for interface_type, mapped from YANG variable /brocade_vswitch_rpc/get_vnetwork_dvs/output/vnetwork_dvs/interface_type (enumeration)
YANG Description: The type of the interface. An 'unknown' type
represents error scenario and should not be used. | f336473:c0:m15 |
def _set_interface_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:8>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:7>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:12>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:5>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:11>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:10>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:6>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, 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.__interface_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for interface_type, mapped from YANG variable /brocade_vswitch_rpc/get_vnetwork_dvs/output/vnetwork_dvs/interface_type (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_interface_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_interface_type() directly.
YANG Description: The type of the interface. An 'unknown' type
represents error scenario and should not be used. | f336473:c0:m16 |
def _get_interface_name(self): | return self.__interface_name<EOL> | Getter method for interface_name, mapped from YANG variable /brocade_vswitch_rpc/get_vnetwork_dvs/output/vnetwork_dvs/interface_name (union)
YANG Description: The Interface value. The interface value is always
interpreted within the context of the value of
'interface-type' leaf:
interface-type interface-name
----------------- --------------------
ethernet slot/port
port-channel Port channel ID
l2vlan Vlan ID
loopback Loopback ID
ve VE Interface ID
unknown Zero-length string.
The value of an 'interface-name' must always be
consistent with the value of the associated
'interface-type'. Attempts to set an interface-name
to a value inconsistent with the associated
'interface-type' must fail with an error. | f336473:c0:m18 |
def _set_interface_name(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=[RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>', '<STR_LIT>': [u'<STR_LIT>']}),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>']}),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=False, 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.__interface_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for interface_name, mapped from YANG variable /brocade_vswitch_rpc/get_vnetwork_dvs/output/vnetwork_dvs/interface_name (union)
If this variable is read-only (config: false) in the
source YANG file, then _set_interface_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_interface_name() directly.
YANG Description: The Interface value. The interface value is always
interpreted within the context of the value of
'interface-type' leaf:
interface-type interface-name
----------------- --------------------
ethernet slot/port
port-channel Port channel ID
l2vlan Vlan ID
loopback Loopback ID
ve VE Interface ID
unknown Zero-length string.
The value of an 'interface-name' must always be
consistent with the value of the associated
'interface-type'. Attempts to set an interface-name
to a value inconsistent with the associated
'interface-type' must fail with an error. | f336473:c0:m19 |
def _get_autobw_template_name(self): | return self.__autobw_template_name<EOL> | Getter method for autobw_template_name, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/autobw_template/autobw_template_name (string) | f336474:c0:m3 |
def _set_autobw_template_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, 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: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.__autobw_template_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for autobw_template_name, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/autobw_template/autobw_template_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_autobw_template_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_autobw_template_name() directly. | f336474:c0:m4 |
def _get_adjustment_interval(self): | return self.__adjustment_interval<EOL> | Getter method for adjustment_interval, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/autobw_template/adjustment_interval (uint32) | f336474:c0:m6 |
def _set_adjustment_interval(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), default=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>)(<NUM_LIT>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': 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.__adjustment_interval = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for adjustment_interval, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/autobw_template/adjustment_interval (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_adjustment_interval is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_adjustment_interval() directly. | f336474:c0:m7 |
def _get_adjustment_threshold(self): | return self.__adjustment_threshold<EOL> | Getter method for adjustment_threshold, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/autobw_template/adjustment_threshold (uint32) | f336474:c0:m9 |
def _set_adjustment_threshold(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:0>), 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.__adjustment_threshold = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for adjustment_threshold, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/autobw_template/adjustment_threshold (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_adjustment_threshold is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_adjustment_threshold() directly. | f336474:c0:m10 |
def _get_min_bandwidth(self): | return self.__min_bandwidth<EOL> | Getter method for min_bandwidth, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/autobw_template/min_bandwidth (uint32) | f336474:c0:m12 |
def _set_min_bandwidth(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=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:0>), 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.__min_bandwidth = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for min_bandwidth, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/autobw_template/min_bandwidth (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_min_bandwidth is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_min_bandwidth() directly. | f336474:c0:m13 |
def _get_max_bandwidth(self): | return self.__max_bandwidth<EOL> | Getter method for max_bandwidth, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/autobw_template/max_bandwidth (uint32) | f336474:c0:m15 |
def _set_max_bandwidth(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), default=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>)(<NUM_LIT>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__max_bandwidth = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for max_bandwidth, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/autobw_template/max_bandwidth (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_max_bandwidth is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_max_bandwidth() directly. | f336474:c0:m16 |
def _get_overflow_limit(self): | return self.__overflow_limit<EOL> | Getter method for overflow_limit, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/autobw_template/overflow_limit (uint32) | f336474:c0:m18 |
def _set_overflow_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:0>), 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.__overflow_limit = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for overflow_limit, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/autobw_template/overflow_limit (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_overflow_limit is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_overflow_limit() directly. | f336474:c0:m19 |
def _get_mode(self): | return self.__mode<EOL> | Getter method for mode, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/autobw_template/mode (autobw-mode) | f336474:c0:m21 |
def _set_mode(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:0>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}},), 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>', 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.__mode = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mode, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/autobw_template/mode (autobw-mode)
If this variable is read-only (config: false) in the
source YANG file, then _set_mode is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mode() directly. | f336474:c0:m22 |
def _get_sample_recording(self): | return self.__sample_recording<EOL> | Getter method for sample_recording, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/autobw_template/sample_recording (enable-disable) | f336474:c0:m24 |
def _set_sample_recording(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:0>}},), 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.__sample_recording = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for sample_recording, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/autobw_template/sample_recording (enable-disable)
If this variable is read-only (config: false) in the
source YANG file, then _set_sample_recording is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_sample_recording() directly. | f336474:c0:m25 |
def _get_underflow_limit(self): | return self.__underflow_limit<EOL> | Getter method for underflow_limit, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/autobw_template/underflow_limit (uint32) | f336474:c0:m27 |
def _set_underflow_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:0>), 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.__underflow_limit = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for underflow_limit, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/autobw_template/underflow_limit (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_underflow_limit is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_underflow_limit() directly. | f336474:c0:m28 |
def _get_interface_dynamic_bypass_disable(self): | return self.__interface_dynamic_bypass_disable<EOL> | Getter method for interface_dynamic_bypass_disable, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/mpls_interface/interface_dynamic_bypass/mpls_interface_dynamic_bypass_sub_cmds/interface_dynamic_bypass_disable (empty) | f336475:c0:m3 |
def _set_interface_dynamic_bypass_disable(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.__interface_dynamic_bypass_disable = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for interface_dynamic_bypass_disable, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/mpls_interface/interface_dynamic_bypass/mpls_interface_dynamic_bypass_sub_cmds/interface_dynamic_bypass_disable (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_interface_dynamic_bypass_disable is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_interface_dynamic_bypass_disable() directly. | f336475:c0:m4 |
def _get_interface_dynamic_bypass_max_bypasses(self): | return self.__interface_dynamic_bypass_max_bypasses<EOL> | Getter method for interface_dynamic_bypass_max_bypasses, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/mpls_interface/interface_dynamic_bypass/mpls_interface_dynamic_bypass_sub_cmds/interface_dynamic_bypass_max_bypasses (uint32) | f336475:c0:m6 |
def _set_interface_dynamic_bypass_max_bypasses(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), default=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>)(<NUM_LIT>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__interface_dynamic_bypass_max_bypasses = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for interface_dynamic_bypass_max_bypasses, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/mpls_interface/interface_dynamic_bypass/mpls_interface_dynamic_bypass_sub_cmds/interface_dynamic_bypass_max_bypasses (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_interface_dynamic_bypass_max_bypasses is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_interface_dynamic_bypass_max_bypasses() directly. | f336475:c0:m7 |
def _get_interface_dynamic_bypass_max_bypasses_per_mp(self): | return self.__interface_dynamic_bypass_max_bypasses_per_mp<EOL> | Getter method for interface_dynamic_bypass_max_bypasses_per_mp, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/mpls_interface/interface_dynamic_bypass/mpls_interface_dynamic_bypass_sub_cmds/interface_dynamic_bypass_max_bypasses_per_mp (uint32) | f336475:c0:m9 |
def _set_interface_dynamic_bypass_max_bypasses_per_mp(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), default=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>)(<NUM_LIT>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__interface_dynamic_bypass_max_bypasses_per_mp = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for interface_dynamic_bypass_max_bypasses_per_mp, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/mpls_interface/interface_dynamic_bypass/mpls_interface_dynamic_bypass_sub_cmds/interface_dynamic_bypass_max_bypasses_per_mp (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_interface_dynamic_bypass_max_bypasses_per_mp is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_interface_dynamic_bypass_max_bypasses_per_mp() directly. | f336475:c0:m10 |
def _get_interface_dynamic_bypass_reoptimize_timer(self): | return self.__interface_dynamic_bypass_reoptimize_timer<EOL> | Getter method for interface_dynamic_bypass_reoptimize_timer, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/mpls_interface/interface_dynamic_bypass/mpls_interface_dynamic_bypass_sub_cmds/interface_dynamic_bypass_reoptimize_timer (uint32) | f336475:c0:m12 |
def _set_interface_dynamic_bypass_reoptimize_timer(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>', 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.__interface_dynamic_bypass_reoptimize_timer = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for interface_dynamic_bypass_reoptimize_timer, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/mpls_interface/interface_dynamic_bypass/mpls_interface_dynamic_bypass_sub_cmds/interface_dynamic_bypass_reoptimize_timer (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_interface_dynamic_bypass_reoptimize_timer is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_interface_dynamic_bypass_reoptimize_timer() directly. | f336475:c0:m13 |
def _get_interface_dynamic_bypass_cos(self): | return self.__interface_dynamic_bypass_cos<EOL> | Getter method for interface_dynamic_bypass_cos, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/mpls_interface/interface_dynamic_bypass/mpls_interface_dynamic_bypass_sub_cmds/interface_dynamic_bypass_cos (uint32) | f336475:c0:m15 |
def _set_interface_dynamic_bypass_cos(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:0>), 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.__interface_dynamic_bypass_cos = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for interface_dynamic_bypass_cos, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/mpls_interface/interface_dynamic_bypass/mpls_interface_dynamic_bypass_sub_cmds/interface_dynamic_bypass_cos (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_interface_dynamic_bypass_cos is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_interface_dynamic_bypass_cos() directly. | f336475:c0:m16 |
def _get_interface_dynamic_bypass_from(self): | return self.__interface_dynamic_bypass_from<EOL> | Getter method for interface_dynamic_bypass_from, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/mpls_interface/interface_dynamic_bypass/mpls_interface_dynamic_bypass_sub_cmds/interface_dynamic_bypass_from (inet:ip-address) | f336475:c0:m18 |
def _set_interface_dynamic_bypass_from(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>'}),RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>'}),], is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, 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.__interface_dynamic_bypass_from = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for interface_dynamic_bypass_from, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/mpls_interface/interface_dynamic_bypass/mpls_interface_dynamic_bypass_sub_cmds/interface_dynamic_bypass_from (inet:ip-address)
If this variable is read-only (config: false) in the
source YANG file, then _set_interface_dynamic_bypass_from is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_interface_dynamic_bypass_from() directly. | f336475:c0:m19 |
def _get_interface_dynamic_bypass_adaptive(self): | return self.__interface_dynamic_bypass_adaptive<EOL> | Getter method for interface_dynamic_bypass_adaptive, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/mpls_interface/interface_dynamic_bypass/mpls_interface_dynamic_bypass_sub_cmds/interface_dynamic_bypass_adaptive (enable-disable) | f336475:c0:m21 |
def _set_interface_dynamic_bypass_adaptive(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:0>}},), 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.__interface_dynamic_bypass_adaptive = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for interface_dynamic_bypass_adaptive, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/mpls_interface/interface_dynamic_bypass/mpls_interface_dynamic_bypass_sub_cmds/interface_dynamic_bypass_adaptive (enable-disable)
If this variable is read-only (config: false) in the
source YANG file, then _set_interface_dynamic_bypass_adaptive is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_interface_dynamic_bypass_adaptive() directly. | f336475:c0:m22 |
def _get_interface_dynamic_bypass_record_route(self): | return self.__interface_dynamic_bypass_record_route<EOL> | Getter method for interface_dynamic_bypass_record_route, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/mpls_interface/interface_dynamic_bypass/mpls_interface_dynamic_bypass_sub_cmds/interface_dynamic_bypass_record_route (enable-disable) | f336475:c0:m24 |
def _set_interface_dynamic_bypass_record_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=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>}},), 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.__interface_dynamic_bypass_record_route = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for interface_dynamic_bypass_record_route, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/mpls_interface/interface_dynamic_bypass/mpls_interface_dynamic_bypass_sub_cmds/interface_dynamic_bypass_record_route (enable-disable)
If this variable is read-only (config: false) in the
source YANG file, then _set_interface_dynamic_bypass_record_route is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_interface_dynamic_bypass_record_route() directly. | f336475:c0:m25 |
def _get_interface_dynamic_bypass_hop_limit(self): | return self.__interface_dynamic_bypass_hop_limit<EOL> | Getter method for interface_dynamic_bypass_hop_limit, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/mpls_interface/interface_dynamic_bypass/mpls_interface_dynamic_bypass_sub_cmds/interface_dynamic_bypass_hop_limit (uint8) | f336475:c0:m27 |
def _set_interface_dynamic_bypass_hop_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=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:8>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), default=RestrictedClassType(base_type=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:8>)(<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>': 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.__interface_dynamic_bypass_hop_limit = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for interface_dynamic_bypass_hop_limit, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/mpls_interface/interface_dynamic_bypass/mpls_interface_dynamic_bypass_sub_cmds/interface_dynamic_bypass_hop_limit (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_interface_dynamic_bypass_hop_limit is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_interface_dynamic_bypass_hop_limit() directly. | f336475:c0:m28 |
def _get_interface_dynamic_bypass_exclude_any(self): | return self.__interface_dynamic_bypass_exclude_any<EOL> | Getter method for interface_dynamic_bypass_exclude_any, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/mpls_interface/interface_dynamic_bypass/mpls_interface_dynamic_bypass_sub_cmds/interface_dynamic_bypass_exclude_any (string) | f336475:c0:m30 |
def _set_interface_dynamic_bypass_exclude_any(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=TypedListType(allowed_type=RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': [u'<STR_LIT>']})), is_leaf=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, 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.__interface_dynamic_bypass_exclude_any = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for interface_dynamic_bypass_exclude_any, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/mpls_interface/interface_dynamic_bypass/mpls_interface_dynamic_bypass_sub_cmds/interface_dynamic_bypass_exclude_any (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_interface_dynamic_bypass_exclude_any is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_interface_dynamic_bypass_exclude_any() directly. | f336475:c0:m31 |
def _get_interface_dynamic_bypass_include_any(self): | return self.__interface_dynamic_bypass_include_any<EOL> | Getter method for interface_dynamic_bypass_include_any, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/mpls_interface/interface_dynamic_bypass/mpls_interface_dynamic_bypass_sub_cmds/interface_dynamic_bypass_include_any (string) | f336475:c0:m33 |
def _set_interface_dynamic_bypass_include_any(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=TypedListType(allowed_type=RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': [u'<STR_LIT>']})), is_leaf=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, 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.__interface_dynamic_bypass_include_any = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for interface_dynamic_bypass_include_any, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/mpls_interface/interface_dynamic_bypass/mpls_interface_dynamic_bypass_sub_cmds/interface_dynamic_bypass_include_any (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_interface_dynamic_bypass_include_any is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_interface_dynamic_bypass_include_any() directly. | f336475:c0:m34 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.