signature stringlengths 8 3.44k | body stringlengths 0 1.41M | docstring stringlengths 1 122k | id stringlengths 5 17 |
|---|---|---|---|
def _get_mode(self): | return self.__mode<EOL> | Getter method for mode, mapped from YANG variable /cfm_config/protocol/cfm/domain_name/ma_name/cfm_ma_sub_commands/mep/cfm_mep_sub_commands/remote_mep/rmep_test_profile/mode (y1731-profile-mode) | f336277:c0:m6 |
def _set_mode(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None}}, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__mode = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mode, mapped from YANG variable /cfm_config/protocol/cfm/domain_name/ma_name/cfm_ma_sub_commands/mep/cfm_mep_sub_commands/remote_mep/rmep_test_profile/mode (y1731-profile-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. | f336277:c0:m7 |
def _get_remote_mep(self): | return self.__remote_mep<EOL> | Getter method for remote_mep, mapped from YANG variable /cfm_config/protocol/cfm/domain_name/ma_name/cfm_ma_sub_commands/mep/cfm_mep_sub_commands/remote_mep/remote_mep (uint32) | f336278:c0:m3 |
def _set_remote_mep(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None}}, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__remote_mep = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for remote_mep, mapped from YANG variable /cfm_config/protocol/cfm/domain_name/ma_name/cfm_ma_sub_commands/mep/cfm_mep_sub_commands/remote_mep/remote_mep (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_remote_mep is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_remote_mep() directly. | f336278:c0:m4 |
def _get_action_profile_association(self): | return self.__action_profile_association<EOL> | Getter method for action_profile_association, mapped from YANG variable /cfm_config/protocol/cfm/domain_name/ma_name/cfm_ma_sub_commands/mep/cfm_mep_sub_commands/remote_mep/action_profile_association (string) | f336278:c0:m9 |
def _set_action_profile_association(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': 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.__action_profile_association = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for action_profile_association, mapped from YANG variable /cfm_config/protocol/cfm/domain_name/ma_name/cfm_ma_sub_commands/mep/cfm_mep_sub_commands/remote_mep/action_profile_association (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_action_profile_association is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_action_profile_association() directly. | f336278:c0:m10 |
def _get_mep_id(self): | return self.__mep_id<EOL> | Getter method for mep_id, mapped from YANG variable /cfm_config/protocol/cfm/domain_name/ma_name/cfm_ma_sub_commands/mep/mep_id (uint32) | f336279:c0:m3 |
def _set_mep_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=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>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None}}, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__mep_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mep_id, mapped from YANG variable /cfm_config/protocol/cfm/domain_name/ma_name/cfm_ma_sub_commands/mep/mep_id (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_mep_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mep_id() directly. | f336279:c0:m4 |
def _get_mep_down_up(self): | return self.__mep_down_up<EOL> | Getter method for mep_down_up, mapped from YANG variable /cfm_config/protocol/cfm/domain_name/ma_name/cfm_ma_sub_commands/mep/mep_down_up (mep-down-up-type) | f336279:c0:m6 |
def _set_mep_down_up(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__mep_down_up = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mep_down_up, mapped from YANG variable /cfm_config/protocol/cfm/domain_name/ma_name/cfm_ma_sub_commands/mep/mep_down_up (mep-down-up-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_mep_down_up is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mep_down_up() directly. | f336279:c0:m7 |
def _get_vlan(self): | return self.__vlan<EOL> | Getter method for vlan, mapped from YANG variable /cfm_config/protocol/cfm/domain_name/ma_name/cfm_ma_sub_commands/mep/vlan (uint32) | f336279:c0:m9 |
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>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__vlan = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vlan, mapped from YANG variable /cfm_config/protocol/cfm/domain_name/ma_name/cfm_ma_sub_commands/mep/vlan (uint32)
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. | f336279:c0:m10 |
def _get_inner_vlan(self): | return self.__inner_vlan<EOL> | Getter method for inner_vlan, mapped from YANG variable /cfm_config/protocol/cfm/domain_name/ma_name/cfm_ma_sub_commands/mep/inner_vlan (uint32) | f336279:c0:m12 |
def _set_inner_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>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__inner_vlan = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for inner_vlan, mapped from YANG variable /cfm_config/protocol/cfm/domain_name/ma_name/cfm_ma_sub_commands/mep/inner_vlan (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_inner_vlan is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_inner_vlan() directly. | f336279:c0:m13 |
def _get_mep_intf_type(self): | return self.__mep_intf_type<EOL> | Getter method for mep_intf_type, mapped from YANG variable /cfm_config/protocol/cfm/domain_name/ma_name/cfm_ma_sub_commands/mep/mep_intf_type (dot1ag-interface-type) | f336279:c0:m15 |
def _set_mep_intf_type(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__mep_intf_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mep_intf_type, mapped from YANG variable /cfm_config/protocol/cfm/domain_name/ma_name/cfm_ma_sub_commands/mep/mep_intf_type (dot1ag-interface-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_mep_intf_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mep_intf_type() directly. | f336279:c0:m16 |
def _get_mep_intf_name(self): | return self.__mep_intf_name<EOL> | Getter method for mep_intf_name, mapped from YANG variable /cfm_config/protocol/cfm/domain_name/ma_name/cfm_ma_sub_commands/mep/mep_intf_name (dot1ag-interface-name) | f336279:c0:m18 |
def _set_mep_intf_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>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': 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.__mep_intf_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mep_intf_name, mapped from YANG variable /cfm_config/protocol/cfm/domain_name/ma_name/cfm_ma_sub_commands/mep/mep_intf_name (dot1ag-interface-name)
If this variable is read-only (config: false) in the
source YANG file, then _set_mep_intf_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mep_intf_name() directly. | f336279:c0:m19 |
def _get_cfm_mep_sub_commands(self): | return self.__cfm_mep_sub_commands<EOL> | Getter method for cfm_mep_sub_commands, mapped from YANG variable /cfm_config/protocol/cfm/domain_name/ma_name/cfm_ma_sub_commands/mep/cfm_mep_sub_commands (container) | f336279:c0:m21 |
def _set_cfm_mep_sub_commands(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=cfm_mep_sub_commands.cfm_mep_sub_commands, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__cfm_mep_sub_commands = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for cfm_mep_sub_commands, mapped from YANG variable /cfm_config/protocol/cfm/domain_name/ma_name/cfm_ma_sub_commands/mep/cfm_mep_sub_commands (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_cfm_mep_sub_commands is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_cfm_mep_sub_commands() directly. | f336279:c0:m22 |
def _get_ccm_interval(self): | return self.__ccm_interval<EOL> | Getter method for ccm_interval, mapped from YANG variable /cfm_config/protocol/cfm/domain_name/ma_name/cfm_ma_sub_commands/ccm_interval (ccm-interval-type) | f336280:c0:m3 |
def _set_ccm_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=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:3>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:5>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:4>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, 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.__ccm_interval = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ccm_interval, mapped from YANG variable /cfm_config/protocol/cfm/domain_name/ma_name/cfm_ma_sub_commands/ccm_interval (ccm-interval-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_ccm_interval is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ccm_interval() directly. | f336280:c0:m4 |
def _get_mip_policy(self): | return self.__mip_policy<EOL> | Getter method for mip_policy, mapped from YANG variable /cfm_config/protocol/cfm/domain_name/ma_name/cfm_ma_sub_commands/mip_policy (mip-policy-type) | f336280:c0:m6 |
def _set_mip_policy(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:default>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, 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.__mip_policy = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mip_policy, mapped from YANG variable /cfm_config/protocol/cfm/domain_name/ma_name/cfm_ma_sub_commands/mip_policy (mip-policy-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_mip_policy is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mip_policy() directly. | f336280:c0:m7 |
def _get_maid_format(self): | return self.__maid_format<EOL> | Getter method for maid_format, mapped from YANG variable /cfm_config/protocol/cfm/domain_name/ma_name/cfm_ma_sub_commands/maid_format (maid-format-type) | f336280:c0:m9 |
def _set_maid_format(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:default>': {'<STR_LIT:value>': <NUM_LIT:0>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, 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.__maid_format = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for maid_format, mapped from YANG variable /cfm_config/protocol/cfm/domain_name/ma_name/cfm_ma_sub_commands/maid_format (maid-format-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_maid_format is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_maid_format() directly. | f336280:c0:m10 |
def _get_mep(self): | return self.__mep<EOL> | Getter method for mep, mapped from YANG variable /cfm_config/protocol/cfm/domain_name/ma_name/cfm_ma_sub_commands/mep (list) | f336280:c0:m12 |
def _set_mep(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>",mep.mep, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT>', extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>'}}), is_container='<STR_LIT:list>', yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:list>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__mep = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mep, mapped from YANG variable /cfm_config/protocol/cfm/domain_name/ma_name/cfm_ma_sub_commands/mep (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_mep is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mep() directly. | f336280:c0:m13 |
def _get_protocol(self): | return self.__protocol<EOL> | Getter method for protocol, mapped from YANG variable /cfm_config/protocol (container) | f336281:c0:m3 |
def _set_protocol(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=protocol.protocol, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=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 /cfm_config/protocol (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_protocol is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_protocol() directly. | f336281:c0:m4 |
def _get_connection_name(self): | return self.__connection_name<EOL> | Getter method for connection_name, mapped from YANG variable /statistics_protocol_state/connection_name (string)
YANG Description: connection name | f336282:c0:m3 |
def _set_connection_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=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, is_keyval=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.__connection_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for connection_name, mapped from YANG variable /statistics_protocol_state/connection_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_connection_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_connection_name() directly.
YANG Description: connection name | f336282:c0:m4 |
def _get_hello_rx_total(self): | return self.__hello_rx_total<EOL> | Getter method for hello_rx_total, mapped from YANG variable /statistics_protocol_state/hello_rx_total (uint64)
YANG Description: Hello Rx total | f336282:c0:m6 |
def _set_hello_rx_total(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:64>), 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.__hello_rx_total = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for hello_rx_total, mapped from YANG variable /statistics_protocol_state/hello_rx_total (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_hello_rx_total is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_hello_rx_total() directly.
YANG Description: Hello Rx total | f336282:c0:m7 |
def _get_hello_tx_total(self): | return self.__hello_tx_total<EOL> | Getter method for hello_tx_total, mapped from YANG variable /statistics_protocol_state/hello_tx_total (uint64)
YANG Description: Hello Tx total | f336282:c0:m9 |
def _set_hello_tx_total(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:64>), 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.__hello_tx_total = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for hello_tx_total, mapped from YANG variable /statistics_protocol_state/hello_tx_total (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_hello_tx_total is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_hello_tx_total() directly.
YANG Description: Hello Tx total | f336282:c0:m10 |
def _get_hello_rx_last(self): | return self.__hello_rx_last<EOL> | Getter method for hello_rx_last, mapped from YANG variable /statistics_protocol_state/hello_rx_last (uint64)
YANG Description: Hello Rx since last clear | f336282:c0:m12 |
def _set_hello_rx_last(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:64>), 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.__hello_rx_last = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for hello_rx_last, mapped from YANG variable /statistics_protocol_state/hello_rx_last (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_hello_rx_last is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_hello_rx_last() directly.
YANG Description: Hello Rx since last clear | f336282:c0:m13 |
def _get_hello_tx_last(self): | return self.__hello_tx_last<EOL> | Getter method for hello_tx_last, mapped from YANG variable /statistics_protocol_state/hello_tx_last (uint64)
YANG Description: Hello Tx since last clear | f336282:c0:m15 |
def _set_hello_tx_last(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:64>), 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.__hello_tx_last = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for hello_tx_last, mapped from YANG variable /statistics_protocol_state/hello_tx_last (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_hello_tx_last is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_hello_tx_last() directly.
YANG Description: Hello Tx since last clear | f336282:c0:m16 |
def _get_echo_req_total(self): | return self.__echo_req_total<EOL> | Getter method for echo_req_total, mapped from YANG variable /statistics_protocol_state/echo_req_total (uint64)
YANG Description: echo req total | f336282:c0:m18 |
def _set_echo_req_total(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:64>), 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.__echo_req_total = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for echo_req_total, mapped from YANG variable /statistics_protocol_state/echo_req_total (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_echo_req_total is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_echo_req_total() directly.
YANG Description: echo req total | f336282:c0:m19 |
def _get_echo_reply_total(self): | return self.__echo_reply_total<EOL> | Getter method for echo_reply_total, mapped from YANG variable /statistics_protocol_state/echo_reply_total (uint64)
YANG Description: echo reply total | f336282:c0:m21 |
def _set_echo_reply_total(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:64>), 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.__echo_reply_total = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for echo_reply_total, mapped from YANG variable /statistics_protocol_state/echo_reply_total (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_echo_reply_total is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_echo_reply_total() directly.
YANG Description: echo reply total | f336282:c0:m22 |
def _get_echo_req_last(self): | return self.__echo_req_last<EOL> | Getter method for echo_req_last, mapped from YANG variable /statistics_protocol_state/echo_req_last (uint64)
YANG Description: echo req since last clear | f336282:c0:m24 |
def _set_echo_req_last(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:64>), 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.__echo_req_last = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for echo_req_last, mapped from YANG variable /statistics_protocol_state/echo_req_last (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_echo_req_last is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_echo_req_last() directly.
YANG Description: echo req since last clear | f336282:c0:m25 |
def _get_echo_reply_last(self): | return self.__echo_reply_last<EOL> | Getter method for echo_reply_last, mapped from YANG variable /statistics_protocol_state/echo_reply_last (uint64)
YANG Description: echo reply since last clear | f336282:c0:m27 |
def _set_echo_reply_last(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:64>), 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.__echo_reply_last = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for echo_reply_last, mapped from YANG variable /statistics_protocol_state/echo_reply_last (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_echo_reply_last is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_echo_reply_last() directly.
YANG Description: echo reply since last clear | f336282:c0:m28 |
def _get_experiment_total(self): | return self.__experiment_total<EOL> | Getter method for experiment_total, mapped from YANG variable /statistics_protocol_state/experiment_total (uint64)
YANG Description: experiment total | f336282:c0:m30 |
def _set_experiment_total(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:64>), 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.__experiment_total = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for experiment_total, mapped from YANG variable /statistics_protocol_state/experiment_total (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_experiment_total is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_experiment_total() directly.
YANG Description: experiment total | f336282:c0:m31 |
def _get_experiment_last(self): | return self.__experiment_last<EOL> | Getter method for experiment_last, mapped from YANG variable /statistics_protocol_state/experiment_last (uint64)
YANG Description: experiment since last clear | f336282:c0:m33 |
def _set_experiment_last(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:64>), 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.__experiment_last = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for experiment_last, mapped from YANG variable /statistics_protocol_state/experiment_last (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_experiment_last is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_experiment_last() directly.
YANG Description: experiment since last clear | f336282:c0:m34 |
def _get_feature_req_total(self): | return self.__feature_req_total<EOL> | Getter method for feature_req_total, mapped from YANG variable /statistics_protocol_state/feature_req_total (uint64)
YANG Description: feature req total | f336282:c0:m36 |
def _set_feature_req_total(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:64>), 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.__feature_req_total = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for feature_req_total, mapped from YANG variable /statistics_protocol_state/feature_req_total (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_feature_req_total is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_feature_req_total() directly.
YANG Description: feature req total | f336282:c0:m37 |
def _get_feature_reply_total(self): | return self.__feature_reply_total<EOL> | Getter method for feature_reply_total, mapped from YANG variable /statistics_protocol_state/feature_reply_total (uint64)
YANG Description: feature reply total | f336282:c0:m39 |
def _set_feature_reply_total(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:64>), 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.__feature_reply_total = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for feature_reply_total, mapped from YANG variable /statistics_protocol_state/feature_reply_total (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_feature_reply_total is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_feature_reply_total() directly.
YANG Description: feature reply total | f336282:c0:m40 |
def _get_feature_req_last(self): | return self.__feature_req_last<EOL> | Getter method for feature_req_last, mapped from YANG variable /statistics_protocol_state/feature_req_last (uint64)
YANG Description: feature req since last clear | f336282:c0:m42 |
def _set_feature_req_last(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:64>), 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.__feature_req_last = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for feature_req_last, mapped from YANG variable /statistics_protocol_state/feature_req_last (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_feature_req_last is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_feature_req_last() directly.
YANG Description: feature req since last clear | f336282:c0:m43 |
def _get_feature_reply_last(self): | return self.__feature_reply_last<EOL> | Getter method for feature_reply_last, mapped from YANG variable /statistics_protocol_state/feature_reply_last (uint64)
YANG Description: feature reply since last clear | f336282:c0:m45 |
def _set_feature_reply_last(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:64>), 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.__feature_reply_last = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for feature_reply_last, mapped from YANG variable /statistics_protocol_state/feature_reply_last (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_feature_reply_last is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_feature_reply_last() directly.
YANG Description: feature reply since last clear | f336282:c0:m46 |
def _get_get_config_req_total(self): | return self.__get_config_req_total<EOL> | Getter method for get_config_req_total, mapped from YANG variable /statistics_protocol_state/get_config_req_total (uint64)
YANG Description: get_config req total | f336282:c0:m48 |
def _set_get_config_req_total(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:64>), 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.__get_config_req_total = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for get_config_req_total, mapped from YANG variable /statistics_protocol_state/get_config_req_total (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_get_config_req_total is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_get_config_req_total() directly.
YANG Description: get_config req total | f336282:c0:m49 |
def _get_get_config_reply_total(self): | return self.__get_config_reply_total<EOL> | Getter method for get_config_reply_total, mapped from YANG variable /statistics_protocol_state/get_config_reply_total (uint64)
YANG Description: get_config reply total | f336282:c0:m51 |
def _set_get_config_reply_total(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:64>), 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.__get_config_reply_total = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for get_config_reply_total, mapped from YANG variable /statistics_protocol_state/get_config_reply_total (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_get_config_reply_total is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_get_config_reply_total() directly.
YANG Description: get_config reply total | f336282:c0:m52 |
def _get_get_config_req_last(self): | return self.__get_config_req_last<EOL> | Getter method for get_config_req_last, mapped from YANG variable /statistics_protocol_state/get_config_req_last (uint64)
YANG Description: get_config req since last clear | f336282:c0:m54 |
def _set_get_config_req_last(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:64>), 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.__get_config_req_last = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for get_config_req_last, mapped from YANG variable /statistics_protocol_state/get_config_req_last (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_get_config_req_last is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_get_config_req_last() directly.
YANG Description: get_config req since last clear | f336282:c0:m55 |
def _get_get_config_reply_last(self): | return self.__get_config_reply_last<EOL> | Getter method for get_config_reply_last, mapped from YANG variable /statistics_protocol_state/get_config_reply_last (uint64)
YANG Description: get_config reply since last clear | f336282:c0:m57 |
def _set_get_config_reply_last(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:64>), 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.__get_config_reply_last = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for get_config_reply_last, mapped from YANG variable /statistics_protocol_state/get_config_reply_last (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_get_config_reply_last is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_get_config_reply_last() directly.
YANG Description: get_config reply since last clear | f336282:c0:m58 |
def _get_set_config_total(self): | return self.__set_config_total<EOL> | Getter method for set_config_total, mapped from YANG variable /statistics_protocol_state/set_config_total (uint64)
YANG Description: set config total | f336282:c0:m60 |
def _set_set_config_total(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:64>), 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.__set_config_total = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for set_config_total, mapped from YANG variable /statistics_protocol_state/set_config_total (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_set_config_total is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_set_config_total() directly.
YANG Description: set config total | f336282:c0:m61 |
def _get_set_config_last(self): | return self.__set_config_last<EOL> | Getter method for set_config_last, mapped from YANG variable /statistics_protocol_state/set_config_last (uint64)
YANG Description: set config since last clear | f336282:c0:m63 |
def _set_set_config_last(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:64>), 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.__set_config_last = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for set_config_last, mapped from YANG variable /statistics_protocol_state/set_config_last (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_set_config_last is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_set_config_last() directly.
YANG Description: set config since last clear | f336282:c0:m64 |
def _get_packet_in_total(self): | return self.__packet_in_total<EOL> | Getter method for packet_in_total, mapped from YANG variable /statistics_protocol_state/packet_in_total (uint64)
YANG Description: packet_in total | f336282:c0:m66 |
def _set_packet_in_total(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:64>), 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.__packet_in_total = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for packet_in_total, mapped from YANG variable /statistics_protocol_state/packet_in_total (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_packet_in_total is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_packet_in_total() directly.
YANG Description: packet_in total | f336282:c0:m67 |
def _get_packet_in_last(self): | return self.__packet_in_last<EOL> | Getter method for packet_in_last, mapped from YANG variable /statistics_protocol_state/packet_in_last (uint64)
YANG Description: packet_in since last clear | f336282:c0:m69 |
def _set_packet_in_last(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:64>), 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.__packet_in_last = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for packet_in_last, mapped from YANG variable /statistics_protocol_state/packet_in_last (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_packet_in_last is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_packet_in_last() directly.
YANG Description: packet_in since last clear | f336282:c0:m70 |
def _get_flow_removed_total(self): | return self.__flow_removed_total<EOL> | Getter method for flow_removed_total, mapped from YANG variable /statistics_protocol_state/flow_removed_total (uint64)
YANG Description: flow_removed total | f336282:c0:m72 |
def _set_flow_removed_total(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:64>), 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.__flow_removed_total = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for flow_removed_total, mapped from YANG variable /statistics_protocol_state/flow_removed_total (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_flow_removed_total is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_flow_removed_total() directly.
YANG Description: flow_removed total | f336282:c0:m73 |
def _get_flow_removed_last(self): | return self.__flow_removed_last<EOL> | Getter method for flow_removed_last, mapped from YANG variable /statistics_protocol_state/flow_removed_last (uint64)
YANG Description: flow_removed since last clear | f336282:c0:m75 |
def _set_flow_removed_last(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:64>), 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.__flow_removed_last = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for flow_removed_last, mapped from YANG variable /statistics_protocol_state/flow_removed_last (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_flow_removed_last is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_flow_removed_last() directly.
YANG Description: flow_removed since last clear | f336282:c0:m76 |
def _get_port_status_total(self): | return self.__port_status_total<EOL> | Getter method for port_status_total, mapped from YANG variable /statistics_protocol_state/port_status_total (uint64)
YANG Description: port_status total | f336282:c0:m78 |
def _set_port_status_total(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:64>), 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.__port_status_total = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for port_status_total, mapped from YANG variable /statistics_protocol_state/port_status_total (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_port_status_total is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_port_status_total() directly.
YANG Description: port_status total | f336282:c0:m79 |
def _get_port_status_last(self): | return self.__port_status_last<EOL> | Getter method for port_status_last, mapped from YANG variable /statistics_protocol_state/port_status_last (uint64)
YANG Description: port_status since last clear | f336282:c0:m81 |
def _set_port_status_last(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:64>), 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.__port_status_last = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for port_status_last, mapped from YANG variable /statistics_protocol_state/port_status_last (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_port_status_last is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_port_status_last() directly.
YANG Description: port_status since last clear | f336282:c0:m82 |
def _get_error_total(self): | return self.__error_total<EOL> | Getter method for error_total, mapped from YANG variable /statistics_protocol_state/error_total (uint64)
YANG Description: error total | f336282:c0:m84 |
def _set_error_total(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:64>), 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.__error_total = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for error_total, mapped from YANG variable /statistics_protocol_state/error_total (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_error_total is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_error_total() directly.
YANG Description: error total | f336282:c0:m85 |
def _get_error_last(self): | return self.__error_last<EOL> | Getter method for error_last, mapped from YANG variable /statistics_protocol_state/error_last (uint64)
YANG Description: error since last clear | f336282:c0:m87 |
def _set_error_last(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:64>), 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.__error_last = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for error_last, mapped from YANG variable /statistics_protocol_state/error_last (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_error_last is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_error_last() directly.
YANG Description: error since last clear | f336282:c0:m88 |
def _get_multipart_req_total(self): | return self.__multipart_req_total<EOL> | Getter method for multipart_req_total, mapped from YANG variable /statistics_protocol_state/multipart_req_total (uint64)
YANG Description: multipart req total | f336282:c0:m90 |
def _set_multipart_req_total(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:64>), 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.__multipart_req_total = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for multipart_req_total, mapped from YANG variable /statistics_protocol_state/multipart_req_total (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_multipart_req_total is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_multipart_req_total() directly.
YANG Description: multipart req total | f336282:c0:m91 |
def _get_multipart_reply_total(self): | return self.__multipart_reply_total<EOL> | Getter method for multipart_reply_total, mapped from YANG variable /statistics_protocol_state/multipart_reply_total (uint64)
YANG Description: multipart reply total | f336282:c0:m93 |
def _set_multipart_reply_total(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:64>), 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.__multipart_reply_total = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for multipart_reply_total, mapped from YANG variable /statistics_protocol_state/multipart_reply_total (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_multipart_reply_total is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_multipart_reply_total() directly.
YANG Description: multipart reply total | f336282:c0:m94 |
def _get_multipart_req_last(self): | return self.__multipart_req_last<EOL> | Getter method for multipart_req_last, mapped from YANG variable /statistics_protocol_state/multipart_req_last (uint64)
YANG Description: multipart req since last clear | f336282:c0:m96 |
def _set_multipart_req_last(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:64>), 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.__multipart_req_last = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for multipart_req_last, mapped from YANG variable /statistics_protocol_state/multipart_req_last (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_multipart_req_last is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_multipart_req_last() directly.
YANG Description: multipart req since last clear | f336282:c0:m97 |
def _get_multipart_reply_last(self): | return self.__multipart_reply_last<EOL> | Getter method for multipart_reply_last, mapped from YANG variable /statistics_protocol_state/multipart_reply_last (uint64)
YANG Description: multipart reply since last clear | f336282:c0:m99 |
def _set_multipart_reply_last(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:64>), 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.__multipart_reply_last = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for multipart_reply_last, mapped from YANG variable /statistics_protocol_state/multipart_reply_last (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_multipart_reply_last is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_multipart_reply_last() directly.
YANG Description: multipart reply since last clear | f336282:c0:m100 |
def _get_packet_out_total(self): | return self.__packet_out_total<EOL> | Getter method for packet_out_total, mapped from YANG variable /statistics_protocol_state/packet_out_total (uint64)
YANG Description: packet_out total | f336282:c0:m102 |
def _set_packet_out_total(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:64>), 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.__packet_out_total = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for packet_out_total, mapped from YANG variable /statistics_protocol_state/packet_out_total (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_packet_out_total is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_packet_out_total() directly.
YANG Description: packet_out total | f336282:c0:m103 |
def _get_packet_out_last(self): | return self.__packet_out_last<EOL> | Getter method for packet_out_last, mapped from YANG variable /statistics_protocol_state/packet_out_last (uint64)
YANG Description: packet_out since last clear | f336282:c0:m105 |
def _set_packet_out_last(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:64>), 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.__packet_out_last = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for packet_out_last, mapped from YANG variable /statistics_protocol_state/packet_out_last (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_packet_out_last is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_packet_out_last() directly.
YANG Description: packet_out since last clear | f336282:c0:m106 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.