signature stringlengths 8 3.44k | body stringlengths 0 1.41M | docstring stringlengths 1 122k | id stringlengths 5 17 |
|---|---|---|---|
def _get_dscp(self): | return self.__dscp<EOL> | Getter method for dscp, mapped from YANG variable /ip_acl/ip/access_list/extended/hide_ip_acl_ext/seq/dscp (union) | f335951:c0:m96 |
def _set_dscp(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>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:20>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:30>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:12>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:10>}, u'<STR_LIT:default>': {'<STR_LIT:value>': <NUM_LIT:0>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:32>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:8>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:16>}},),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>', 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.__dscp = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for dscp, mapped from YANG variable /ip_acl/ip/access_list/extended/hide_ip_acl_ext/seq/dscp (union)
If this variable is read-only (config: false) in the
source YANG file, then _set_dscp is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_dscp() directly. | f335951:c0:m97 |
def _get_dscp_force(self): | return self.__dscp_force<EOL> | Getter method for dscp_force, mapped from YANG variable /ip_acl/ip/access_list/extended/hide_ip_acl_ext/seq/dscp_force (dscprmrk-uint) | f335951:c0:m99 |
def _set_dscp_force(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>', 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.__dscp_force = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for dscp_force, mapped from YANG variable /ip_acl/ip/access_list/extended/hide_ip_acl_ext/seq/dscp_force (dscprmrk-uint)
If this variable is read-only (config: false) in the
source YANG file, then _set_dscp_force is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_dscp_force() directly. | f335951:c0:m100 |
def _get_drop_precedence_force(self): | return self.__drop_precedence_force<EOL> | Getter method for drop_precedence_force, mapped from YANG variable /ip_acl/ip/access_list/extended/hide_ip_acl_ext/seq/drop_precedence_force (drop-prec-uint) | f335951:c0:m102 |
def _set_drop_precedence_force(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>', 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.__drop_precedence_force = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for drop_precedence_force, mapped from YANG variable /ip_acl/ip/access_list/extended/hide_ip_acl_ext/seq/drop_precedence_force (drop-prec-uint)
If this variable is read-only (config: false) in the
source YANG file, then _set_drop_precedence_force is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_drop_precedence_force() directly. | f335951:c0:m103 |
def _get_urg(self): | return self.__urg<EOL> | Getter method for urg, mapped from YANG variable /ip_acl/ip/access_list/extended/hide_ip_acl_ext/seq/urg (empty) | f335951:c0:m105 |
def _set_urg(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': 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.__urg = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for urg, mapped from YANG variable /ip_acl/ip/access_list/extended/hide_ip_acl_ext/seq/urg (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_urg is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_urg() directly. | f335951:c0:m106 |
def _get_ack(self): | return self.__ack<EOL> | Getter method for ack, mapped from YANG variable /ip_acl/ip/access_list/extended/hide_ip_acl_ext/seq/ack (empty) | f335951:c0:m108 |
def _set_ack(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': 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.__ack = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ack, mapped from YANG variable /ip_acl/ip/access_list/extended/hide_ip_acl_ext/seq/ack (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_ack is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ack() directly. | f335951:c0:m109 |
def _get_push(self): | return self.__push<EOL> | Getter method for push, mapped from YANG variable /ip_acl/ip/access_list/extended/hide_ip_acl_ext/seq/push (empty) | f335951:c0:m111 |
def _set_push(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': 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.__push = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for push, mapped from YANG variable /ip_acl/ip/access_list/extended/hide_ip_acl_ext/seq/push (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_push is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_push() directly. | f335951:c0:m112 |
def _get_fin(self): | return self.__fin<EOL> | Getter method for fin, mapped from YANG variable /ip_acl/ip/access_list/extended/hide_ip_acl_ext/seq/fin (empty) | f335951:c0:m114 |
def _set_fin(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': 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.__fin = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for fin, mapped from YANG variable /ip_acl/ip/access_list/extended/hide_ip_acl_ext/seq/fin (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_fin is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_fin() directly. | f335951:c0:m115 |
def _get_rst(self): | return self.__rst<EOL> | Getter method for rst, mapped from YANG variable /ip_acl/ip/access_list/extended/hide_ip_acl_ext/seq/rst (empty) | f335951:c0:m117 |
def _set_rst(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': 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.__rst = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rst, mapped from YANG variable /ip_acl/ip/access_list/extended/hide_ip_acl_ext/seq/rst (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_rst is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rst() directly. | f335951:c0:m118 |
def _get_sync(self): | return self.__sync<EOL> | Getter method for sync, mapped from YANG variable /ip_acl/ip/access_list/extended/hide_ip_acl_ext/seq/sync (empty) | f335951:c0:m120 |
def _set_sync(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': 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.__sync = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for sync, mapped from YANG variable /ip_acl/ip/access_list/extended/hide_ip_acl_ext/seq/sync (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_sync is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_sync() directly. | f335951:c0:m121 |
def _get_vlan(self): | return self.__vlan<EOL> | Getter method for vlan, mapped from YANG variable /ip_acl/ip/access_list/extended/hide_ip_acl_ext/seq/vlan (interface:vlan-type)
YANG Description: Vlan | f335951:c0:m123 |
def _set_vlan(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>', 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.__vlan = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vlan, mapped from YANG variable /ip_acl/ip/access_list/extended/hide_ip_acl_ext/seq/vlan (interface:vlan-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_vlan is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vlan() directly.
YANG Description: Vlan | f335951:c0:m124 |
def _get_count(self): | return self.__count<EOL> | Getter method for count, mapped from YANG variable /ip_acl/ip/access_list/extended/hide_ip_acl_ext/seq/count (empty) | f335951:c0:m126 |
def _set_count(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="<STR_LIT:count>", rest_name="<STR_LIT:count>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__count = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for count, mapped from YANG variable /ip_acl/ip/access_list/extended/hide_ip_acl_ext/seq/count (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_count is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_count() directly. | f335951:c0:m127 |
def _get_log(self): | return self.__log<EOL> | Getter method for log, mapped from YANG variable /ip_acl/ip/access_list/extended/hide_ip_acl_ext/seq/log (empty) | f335951:c0:m129 |
def _set_log(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': 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.__log = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for log, mapped from YANG variable /ip_acl/ip/access_list/extended/hide_ip_acl_ext/seq/log (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_log is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_log() directly. | f335951:c0:m130 |
def _get_mirror(self): | return self.__mirror<EOL> | Getter method for mirror, mapped from YANG variable /ip_acl/ip/access_list/extended/hide_ip_acl_ext/seq/mirror (empty) | f335951:c0:m132 |
def _set_mirror(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': 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.__mirror = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mirror, mapped from YANG variable /ip_acl/ip/access_list/extended/hide_ip_acl_ext/seq/mirror (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_mirror is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mirror() directly. | f335951:c0:m133 |
def _get_copy_sflow(self): | return self.__copy_sflow<EOL> | Getter method for copy_sflow, mapped from YANG variable /ip_acl/ip/access_list/extended/hide_ip_acl_ext/seq/copy_sflow (empty) | f335951:c0:m135 |
def _set_copy_sflow(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>': 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.__copy_sflow = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for copy_sflow, mapped from YANG variable /ip_acl/ip/access_list/extended/hide_ip_acl_ext/seq/copy_sflow (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_copy_sflow is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_copy_sflow() directly. | f335951:c0:m136 |
def _get_access_list(self): | return self.__access_list<EOL> | Getter method for access_list, mapped from YANG variable /ip_acl/ip/access_list (container) | f335952:c0:m3 |
def _set_access_list(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=access_list.access_list, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__access_list = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for access_list, mapped from YANG variable /ip_acl/ip/access_list (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_access_list is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_access_list() directly. | f335952:c0:m4 |
def _get_firstauthor(self): | return self.__firstauthor<EOL> | Getter method for firstauthor, mapped from YANG variable /aaa_config/aaa/authorization/command/firstauthor (enumeration) | f335953:c0:m3 |
def _set_firstauthor(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:2>}, u'<STR_LIT:none>': {'<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: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.__firstauthor = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for firstauthor, mapped from YANG variable /aaa_config/aaa/authorization/command/firstauthor (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_firstauthor is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_firstauthor() directly. | f335953:c0:m4 |
def _get_secondauthor(self): | return self.__secondauthor<EOL> | Getter method for secondauthor, mapped from YANG variable /aaa_config/aaa/authorization/command/secondauthor (enumeration) | f335953:c0:m6 |
def _set_secondauthor(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: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>', u'<STR_LIT>': None, u'<STR_LIT>': u"<STR_LIT>"}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__secondauthor = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for secondauthor, mapped from YANG variable /aaa_config/aaa/authorization/command/secondauthor (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_secondauthor is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_secondauthor() directly. | f335953:c0:m7 |
def _get_command(self): | return self.__command<EOL> | Getter method for command, mapped from YANG variable /aaa_config/aaa/authorization/command (container) | f335954:c0:m3 |
def _set_command(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=command.command, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u"<STR_LIT>", u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': 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.__command = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for command, mapped from YANG variable /aaa_config/aaa/authorization/command (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_command is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_command() directly. | f335954:c0:m4 |
def _get_authentication(self): | return self.__authentication<EOL> | Getter method for authentication, mapped from YANG variable /aaa_config/aaa/authentication (container) | f335955:c0:m3 |
def _set_authentication(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=authentication.authentication, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__authentication = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for authentication, mapped from YANG variable /aaa_config/aaa/authentication (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_authentication is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_authentication() directly. | f335955:c0:m4 |
def _get_accounting(self): | return self.__accounting<EOL> | Getter method for accounting, mapped from YANG variable /aaa_config/aaa/accounting (container) | f335955:c0:m6 |
def _set_accounting(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=accounting.accounting, 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.__accounting = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for accounting, mapped from YANG variable /aaa_config/aaa/accounting (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_accounting is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_accounting() directly. | f335955:c0:m7 |
def _get_authorization(self): | return self.__authorization<EOL> | Getter method for authorization, mapped from YANG variable /aaa_config/aaa/authorization (container) | f335955:c0:m9 |
def _set_authorization(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=authorization.authorization, 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.__authorization = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for authorization, mapped from YANG variable /aaa_config/aaa/authorization (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_authorization is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_authorization() directly. | f335955:c0:m10 |
def _get_peer_ldp_id(self): | return self.__peer_ldp_id<EOL> | Getter method for peer_ldp_id, mapped from YANG variable /mpls_state/ldp/ldp_session/peer_ldp_id (inet:ipv4-address)
YANG Description: Peer IP address | f335956:c0:m3 |
def _set_peer_ldp_id(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>'}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__peer_ldp_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for peer_ldp_id, mapped from YANG variable /mpls_state/ldp/ldp_session/peer_ldp_id (inet:ipv4-address)
If this variable is read-only (config: false) in the
source YANG file, then _set_peer_ldp_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_peer_ldp_id() directly.
YANG Description: Peer IP address | f335956:c0:m4 |
def _get_peer_label_space_id(self): | return self.__peer_label_space_id<EOL> | Getter method for peer_label_space_id, mapped from YANG variable /mpls_state/ldp/ldp_session/peer_label_space_id (uint8)
YANG Description: Peer label space ID | f335956:c0:m6 |
def _set_peer_label_space_id(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:8>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__peer_label_space_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for peer_label_space_id, mapped from YANG variable /mpls_state/ldp/ldp_session/peer_label_space_id (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_peer_label_space_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_peer_label_space_id() directly.
YANG Description: Peer label space ID | f335956:c0:m7 |
def _get_state(self): | return self.__state<EOL> | Getter method for state, mapped from YANG variable /mpls_state/ldp/ldp_session/state (string)
YANG Description: state | f335956:c0:m9 |
def _set_state(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT:state>", rest_name="<STR_LIT:state>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for state, mapped from YANG variable /mpls_state/ldp/ldp_session/state (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_state is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_state() directly.
YANG Description: state | f335956:c0:m10 |
def _get_adjacency(self): | return self.__adjacency<EOL> | Getter method for adjacency, mapped from YANG variable /mpls_state/ldp/ldp_session/adjacency (string)
YANG Description: adjacency | f335956:c0:m12 |
def _set_adjacency(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__adjacency = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for adjacency, mapped from YANG variable /mpls_state/ldp/ldp_session/adjacency (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_adjacency is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_adjacency() directly.
YANG Description: adjacency | f335956:c0:m13 |
def _get_role(self): | return self.__role<EOL> | Getter method for role, mapped from YANG variable /mpls_state/ldp/ldp_session/role (string)
YANG Description: role | f335956:c0:m15 |
def _set_role(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__role = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for role, mapped from YANG variable /mpls_state/ldp/ldp_session/role (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_role is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_role() directly.
YANG Description: role | f335956:c0:m16 |
def _get_max_hold(self): | return self.__max_hold<EOL> | Getter method for max_hold, mapped from YANG variable /mpls_state/ldp/ldp_session/max_hold (uint32)
YANG Description: maxHold | f335956:c0:m18 |
def _set_max_hold(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__max_hold = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for max_hold, mapped from YANG variable /mpls_state/ldp/ldp_session/max_hold (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_max_hold is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_max_hold() directly.
YANG Description: maxHold | f335956:c0:m19 |
def _get_time_left(self): | return self.__time_left<EOL> | Getter method for time_left, mapped from YANG variable /mpls_state/ldp/ldp_session/time_left (uint32)
YANG Description: timeLeft | f335956:c0:m21 |
def _set_time_left(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__time_left = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for time_left, mapped from YANG variable /mpls_state/ldp/ldp_session/time_left (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_time_left is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_time_left() directly.
YANG Description: timeLeft | f335956:c0:m22 |
def _get_session_status(self): | return self.__session_status<EOL> | Getter method for session_status, mapped from YANG variable /mpls_state/ldp/ldp_session/session_status (string)
YANG Description: sessionStatus | f335956:c0:m24 |
def _set_session_status(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__session_status = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for session_status, mapped from YANG variable /mpls_state/ldp/ldp_session/session_status (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_session_status is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_session_status() directly.
YANG Description: sessionStatus | f335956:c0:m25 |
def _get_local_ldp_id(self): | return self.__local_ldp_id<EOL> | Getter method for local_ldp_id, mapped from YANG variable /mpls_state/ldp/ldp_session/local_ldp_id (string)
YANG Description: localLdpId | f335956:c0:m27 |
def _set_local_ldp_id(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__local_ldp_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for local_ldp_id, mapped from YANG variable /mpls_state/ldp/ldp_session/local_ldp_id (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_local_ldp_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_local_ldp_id() directly.
YANG Description: localLdpId | f335956:c0:m28 |
def _get_local_lblspc_id(self): | return self.__local_lblspc_id<EOL> | Getter method for local_lblspc_id, mapped from YANG variable /mpls_state/ldp/ldp_session/local_lblspc_id (string)
YANG Description: local_lblspc_id | f335956:c0:m30 |
def _set_local_lblspc_id(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__local_lblspc_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for local_lblspc_id, mapped from YANG variable /mpls_state/ldp/ldp_session/local_lblspc_id (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_local_lblspc_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_local_lblspc_id() directly.
YANG Description: local_lblspc_id | f335956:c0:m31 |
def _get_next_keepalive(self): | return self.__next_keepalive<EOL> | Getter method for next_keepalive, mapped from YANG variable /mpls_state/ldp/ldp_session/next_keepalive (uint32)
YANG Description: nextKeepalive | f335956:c0:m33 |
def _set_next_keepalive(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.__next_keepalive = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for next_keepalive, mapped from YANG variable /mpls_state/ldp/ldp_session/next_keepalive (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_next_keepalive is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_next_keepalive() directly.
YANG Description: nextKeepalive | f335956:c0:m34 |
def _get_entity_index(self): | return self.__entity_index<EOL> | Getter method for entity_index, mapped from YANG variable /mpls_state/ldp/ldp_session/entity_index (uint32)
YANG Description: entityIndex | f335956:c0:m36 |
def _set_entity_index(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.__entity_index = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for entity_index, mapped from YANG variable /mpls_state/ldp/ldp_session/entity_index (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_entity_index is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_entity_index() directly.
YANG Description: entityIndex | f335956:c0:m37 |
def _get_targeted_adj_added(self): | return self.__targeted_adj_added<EOL> | Getter method for targeted_adj_added, mapped from YANG variable /mpls_state/ldp/ldp_session/targeted_adj_added (string)
YANG Description: targetedAdjAdded | f335956:c0:m39 |
def _set_targeted_adj_added(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__targeted_adj_added = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for targeted_adj_added, mapped from YANG variable /mpls_state/ldp/ldp_session/targeted_adj_added (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_targeted_adj_added is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_targeted_adj_added() directly.
YANG Description: targetedAdjAdded | f335956:c0:m40 |
def _get_is_retry(self): | return self.__is_retry<EOL> | Getter method for is_retry, mapped from YANG variable /mpls_state/ldp/ldp_session/is_retry (boolean)
YANG Description: isRetry | f335956:c0:m42 |
def _set_is_retry(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__is_retry = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for is_retry, mapped from YANG variable /mpls_state/ldp/ldp_session/is_retry (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_is_retry is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_is_retry() directly.
YANG Description: isRetry | f335956:c0:m43 |
def _get_next_retry(self): | return self.__next_retry<EOL> | Getter method for next_retry, mapped from YANG variable /mpls_state/ldp/ldp_session/next_retry (uint32)
YANG Description: nextRetry | f335956:c0:m45 |
def _set_next_retry(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.__next_retry = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for next_retry, mapped from YANG variable /mpls_state/ldp/ldp_session/next_retry (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_next_retry is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_next_retry() directly.
YANG Description: nextRetry | f335956:c0:m46 |
def _get_keepalive_interval(self): | return self.__keepalive_interval<EOL> | Getter method for keepalive_interval, mapped from YANG variable /mpls_state/ldp/ldp_session/keepalive_interval (uint32)
YANG Description: keepaliveInterval | f335956:c0:m48 |
def _set_keepalive_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=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.__keepalive_interval = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for keepalive_interval, mapped from YANG variable /mpls_state/ldp/ldp_session/keepalive_interval (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_keepalive_interval is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_keepalive_interval() directly.
YANG Description: keepaliveInterval | f335956:c0:m49 |
def _get_local_keepalive_timeout(self): | return self.__local_keepalive_timeout<EOL> | Getter method for local_keepalive_timeout, mapped from YANG variable /mpls_state/ldp/ldp_session/local_keepalive_timeout (uint32)
YANG Description: localKeepaliveTimeout | f335956:c0:m51 |
def _set_local_keepalive_timeout(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__local_keepalive_timeout = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for local_keepalive_timeout, mapped from YANG variable /mpls_state/ldp/ldp_session/local_keepalive_timeout (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_local_keepalive_timeout is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_local_keepalive_timeout() directly.
YANG Description: localKeepaliveTimeout | f335956:c0:m52 |
def _get_peer_proposed_keepalive_timeout(self): | return self.__peer_proposed_keepalive_timeout<EOL> | Getter method for peer_proposed_keepalive_timeout, mapped from YANG variable /mpls_state/ldp/ldp_session/peer_proposed_keepalive_timeout (uint32)
YANG Description: peerProposedKeepaliveTimeout | f335956:c0:m54 |
def _set_peer_proposed_keepalive_timeout(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__peer_proposed_keepalive_timeout = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for peer_proposed_keepalive_timeout, mapped from YANG variable /mpls_state/ldp/ldp_session/peer_proposed_keepalive_timeout (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_peer_proposed_keepalive_timeout is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_peer_proposed_keepalive_timeout() directly.
YANG Description: peerProposedKeepaliveTimeout | f335956:c0:m55 |
def _get_session_up_time(self): | return self.__session_up_time<EOL> | Getter method for session_up_time, mapped from YANG variable /mpls_state/ldp/ldp_session/session_up_time (string)
YANG Description: sessionUpTime | f335956:c0:m57 |
def _set_session_up_time(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__session_up_time = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for session_up_time, mapped from YANG variable /mpls_state/ldp/ldp_session/session_up_time (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_session_up_time is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_session_up_time() directly.
YANG Description: sessionUpTime | f335956:c0:m58 |
def _get_md5_auth_key(self): | return self.__md5_auth_key<EOL> | Getter method for md5_auth_key, mapped from YANG variable /mpls_state/ldp/ldp_session/md5_auth_key (string)
YANG Description: md5AuthKey | f335956:c0:m60 |
def _set_md5_auth_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=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__md5_auth_key = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for md5_auth_key, mapped from YANG variable /mpls_state/ldp/ldp_session/md5_auth_key (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_md5_auth_key is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_md5_auth_key() directly.
YANG Description: md5AuthKey | f335956:c0:m61 |
def _get_tcp_conn_local(self): | return self.__tcp_conn_local<EOL> | Getter method for tcp_conn_local, mapped from YANG variable /mpls_state/ldp/ldp_session/tcp_conn_local (string)
YANG Description: tcpConnLocal | f335956:c0:m63 |
def _set_tcp_conn_local(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__tcp_conn_local = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for tcp_conn_local, mapped from YANG variable /mpls_state/ldp/ldp_session/tcp_conn_local (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_tcp_conn_local is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tcp_conn_local() directly.
YANG Description: tcpConnLocal | f335956:c0:m64 |
def _get_tcp_conn_remote(self): | return self.__tcp_conn_remote<EOL> | Getter method for tcp_conn_remote, mapped from YANG variable /mpls_state/ldp/ldp_session/tcp_conn_remote (string)
YANG Description: tcpConnRemote | f335956:c0:m66 |
def _set_tcp_conn_remote(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__tcp_conn_remote = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for tcp_conn_remote, mapped from YANG variable /mpls_state/ldp/ldp_session/tcp_conn_remote (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_tcp_conn_remote is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tcp_conn_remote() directly.
YANG Description: tcpConnRemote | f335956:c0:m67 |
def _get_tcp_state(self): | return self.__tcp_state<EOL> | Getter method for tcp_state, mapped from YANG variable /mpls_state/ldp/ldp_session/tcp_state (string)
YANG Description: tcpState | f335956:c0:m69 |
def _set_tcp_state(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__tcp_state = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for tcp_state, mapped from YANG variable /mpls_state/ldp/ldp_session/tcp_state (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_tcp_state is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tcp_state() directly.
YANG Description: tcpState | f335956:c0:m70 |
def _get_num_fecs_received_from_peer(self): | return self.__num_fecs_received_from_peer<EOL> | Getter method for num_fecs_received_from_peer, mapped from YANG variable /mpls_state/ldp/ldp_session/num_fecs_received_from_peer (uint32)
YANG Description: numFecsReceivedFromPeer | f335956:c0:m72 |
def _set_num_fecs_received_from_peer(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__num_fecs_received_from_peer = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for num_fecs_received_from_peer, mapped from YANG variable /mpls_state/ldp/ldp_session/num_fecs_received_from_peer (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_num_fecs_received_from_peer is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_num_fecs_received_from_peer() directly.
YANG Description: numFecsReceivedFromPeer | f335956:c0:m73 |
def _get_num_fecs_installed_from_peer(self): | return self.__num_fecs_installed_from_peer<EOL> | Getter method for num_fecs_installed_from_peer, mapped from YANG variable /mpls_state/ldp/ldp_session/num_fecs_installed_from_peer (uint32)
YANG Description: numFecsInstalledFromPeer | f335956:c0:m75 |
def _set_num_fecs_installed_from_peer(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__num_fecs_installed_from_peer = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for num_fecs_installed_from_peer, mapped from YANG variable /mpls_state/ldp/ldp_session/num_fecs_installed_from_peer (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_num_fecs_installed_from_peer is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_num_fecs_installed_from_peer() directly.
YANG Description: numFecsInstalledFromPeer | f335956:c0:m76 |
def _get_is_fecs_pending_uninstall(self): | return self.__is_fecs_pending_uninstall<EOL> | Getter method for is_fecs_pending_uninstall, mapped from YANG variable /mpls_state/ldp/ldp_session/is_fecs_pending_uninstall (boolean)
YANG Description: isFecsPendingUninstall | f335956:c0:m78 |
def _set_is_fecs_pending_uninstall(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__is_fecs_pending_uninstall = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for is_fecs_pending_uninstall, mapped from YANG variable /mpls_state/ldp/ldp_session/is_fecs_pending_uninstall (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_is_fecs_pending_uninstall is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_is_fecs_pending_uninstall() directly.
YANG Description: isFecsPendingUninstall | f335956:c0:m79 |
def _get_num_fecs_filtered_out(self): | return self.__num_fecs_filtered_out<EOL> | Getter method for num_fecs_filtered_out, mapped from YANG variable /mpls_state/ldp/ldp_session/num_fecs_filtered_out (uint32)
YANG Description: numFecsFilteredOut | f335956:c0:m81 |
def _set_num_fecs_filtered_out(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__num_fecs_filtered_out = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for num_fecs_filtered_out, mapped from YANG variable /mpls_state/ldp/ldp_session/num_fecs_filtered_out (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_num_fecs_filtered_out is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_num_fecs_filtered_out() directly.
YANG Description: numFecsFilteredOut | f335956:c0:m82 |
def _get_num_fecs_filtered_in(self): | return self.__num_fecs_filtered_in<EOL> | Getter method for num_fecs_filtered_in, mapped from YANG variable /mpls_state/ldp/ldp_session/num_fecs_filtered_in (uint32)
YANG Description: numFecsFilteredIn | f335956:c0:m84 |
def _set_num_fecs_filtered_in(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__num_fecs_filtered_in = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for num_fecs_filtered_in, mapped from YANG variable /mpls_state/ldp/ldp_session/num_fecs_filtered_in (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_num_fecs_filtered_in is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_num_fecs_filtered_in() directly.
YANG Description: numFecsFilteredIn | f335956:c0:m85 |
def _get_filter_prefix_list_name(self): | return self.__filter_prefix_list_name<EOL> | Getter method for filter_prefix_list_name, mapped from YANG variable /mpls_state/ldp/ldp_session/filter_prefix_list_name (string)
YANG Description: dataFilterPrefixList | f335956:c0:m87 |
def _set_filter_prefix_list_name(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__filter_prefix_list_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for filter_prefix_list_name, mapped from YANG variable /mpls_state/ldp/ldp_session/filter_prefix_list_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_filter_prefix_list_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_filter_prefix_list_name() directly.
YANG Description: dataFilterPrefixList | f335956:c0:m88 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.