signature
stringlengths 8
3.44k
| body
stringlengths 0
1.41M
| docstring
stringlengths 1
122k
| id
stringlengths 5
17
|
|---|---|---|---|
def _get_rate(self): | return self.__rate<EOL> | Getter method for rate, mapped from YANG variable /openflow_state/meter/meter_info_list/meterband_info_list/rate (uint32)
YANG Description: Rate | f336804:c0:m6 |
def _set_rate(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.__rate = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rate, mapped from YANG variable /openflow_state/meter/meter_info_list/meterband_info_list/rate (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_rate is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rate() directly.
YANG Description: Rate | f336804:c0:m7 |
def _get_burst_size(self): | return self.__burst_size<EOL> | Getter method for burst_size, mapped from YANG variable /openflow_state/meter/meter_info_list/meterband_info_list/burst_size (uint32)
YANG Description: Burst size | f336804:c0:m9 |
def _set_burst_size(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.__burst_size = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for burst_size, mapped from YANG variable /openflow_state/meter/meter_info_list/meterband_info_list/burst_size (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_burst_size is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_burst_size() directly.
YANG Description: Burst size | f336804:c0:m10 |
def _get_in_packet_band_count(self): | return self.__in_packet_band_count<EOL> | Getter method for in_packet_band_count, mapped from YANG variable /openflow_state/meter/meter_info_list/meterband_info_list/in_packet_band_count (uint32)
YANG Description: In packet band count | f336804:c0:m12 |
def _set_in_packet_band_count(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__in_packet_band_count = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for in_packet_band_count, mapped from YANG variable /openflow_state/meter/meter_info_list/meterband_info_list/in_packet_band_count (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_in_packet_band_count is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_in_packet_band_count() directly.
YANG Description: In packet band count | f336804:c0:m13 |
def _get_in_byte_band_count(self): | return self.__in_byte_band_count<EOL> | Getter method for in_byte_band_count, mapped from YANG variable /openflow_state/meter/meter_info_list/meterband_info_list/in_byte_band_count (uint32)
YANG Description: In byte band count | f336804:c0:m15 |
def _set_in_byte_band_count(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__in_byte_band_count = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for in_byte_band_count, mapped from YANG variable /openflow_state/meter/meter_info_list/meterband_info_list/in_byte_band_count (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_in_byte_band_count is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_in_byte_band_count() directly.
YANG Description: In byte band count | f336804:c0:m16 |
def _get_profile_name(self): | return self.__profile_name<EOL> | Getter method for profile_name, mapped from YANG variable /sflow_profile/profile_name (profile-name-type) | f336805:c0:m3 |
def _set_profile_name(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>'}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': 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.__profile_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for profile_name, mapped from YANG variable /sflow_profile/profile_name (profile-name-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_profile_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_profile_name() directly. | f336805:c0:m4 |
def _get_profile_sampling_rate(self): | return self.__profile_sampling_rate<EOL> | Getter method for profile_sampling_rate, mapped from YANG variable /sflow_profile/profile_sampling_rate (uint32) | f336805:c0:m6 |
def _set_profile_sampling_rate(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>': 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.__profile_sampling_rate = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for profile_sampling_rate, mapped from YANG variable /sflow_profile/profile_sampling_rate (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_profile_sampling_rate is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_profile_sampling_rate() directly. | f336805:c0:m7 |
def _get_rmep_id(self): | return self.__rmep_id<EOL> | Getter method for rmep_id, mapped from YANG variable /cfm_state/cfm_connectivity/domain/ma/mep/rmep/rmep_id (uint16)
YANG Description: rmep id | f336806:c0:m3 |
def _set_rmep_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:16>), 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.__rmep_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rmep_id, mapped from YANG variable /cfm_state/cfm_connectivity/domain/ma/mep/rmep/rmep_id (uint16)
If this variable is read-only (config: false) in the
source YANG file, then _set_rmep_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rmep_id() directly.
YANG Description: rmep id | f336806:c0:m4 |
def _get_rmep_mac(self): | return self.__rmep_mac<EOL> | Getter method for rmep_mac, mapped from YANG variable /cfm_state/cfm_connectivity/domain/ma/mep/rmep/rmep_mac (string)
YANG Description: RMEP MAC | f336806:c0:m6 |
def _set_rmep_mac(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, 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.__rmep_mac = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rmep_mac, mapped from YANG variable /cfm_state/cfm_connectivity/domain/ma/mep/rmep/rmep_mac (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_rmep_mac is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rmep_mac() directly.
YANG Description: RMEP MAC | f336806:c0:m7 |
def _get_vlan_id(self): | return self.__vlan_id<EOL> | Getter method for vlan_id, mapped from YANG variable /cfm_state/cfm_connectivity/domain/ma/mep/rmep/vlan_id (uint32)
YANG Description: VLAN Id | f336806:c0:m9 |
def _set_vlan_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=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.__vlan_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vlan_id, mapped from YANG variable /cfm_state/cfm_connectivity/domain/ma/mep/rmep/vlan_id (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_vlan_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vlan_id() directly.
YANG Description: VLAN Id | f336806:c0:m10 |
def _get_rmep_port(self): | return self.__rmep_port<EOL> | Getter method for rmep_port, mapped from YANG variable /cfm_state/cfm_connectivity/domain/ma/mep/rmep/rmep_port (string)
YANG Description: RMEP Port | f336806:c0:m12 |
def _set_rmep_port(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=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.__rmep_port = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rmep_port, mapped from YANG variable /cfm_state/cfm_connectivity/domain/ma/mep/rmep/rmep_port (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_rmep_port is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rmep_port() directly.
YANG Description: RMEP Port | f336806:c0:m13 |
def _get_rmep_state(self): | return self.__rmep_state<EOL> | Getter method for rmep_state, mapped from YANG variable /cfm_state/cfm_connectivity/domain/ma/mep/rmep/rmep_state (uint8)
YANG Description: RMEP State | f336806:c0:m15 |
def _set_rmep_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=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, 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.__rmep_state = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rmep_state, mapped from YANG variable /cfm_state/cfm_connectivity/domain/ma/mep/rmep/rmep_state (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_rmep_state is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rmep_state() directly.
YANG Description: RMEP State | f336806:c0:m16 |
def _get_mep_id(self): | return self.__mep_id<EOL> | Getter method for mep_id, mapped from YANG variable /cfm_state/cfm_connectivity/domain/ma/mep/mep_id (uint16)
YANG Description: mep id | f336807: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=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']},int_size=<NUM_LIT:16>), 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.__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_state/cfm_connectivity/domain/ma/mep/mep_id (uint16)
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.
YANG Description: mep id | f336807:c0:m4 |
def _get_mep_direction(self): | return self.__mep_direction<EOL> | Getter method for mep_direction, mapped from YANG variable /cfm_state/cfm_connectivity/domain/ma/mep/mep_direction (mep-status)
YANG Description: MEP Direction | f336807:c0:m6 |
def _set_mep_direction(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>': {'<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, 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.__mep_direction = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mep_direction, mapped from YANG variable /cfm_state/cfm_connectivity/domain/ma/mep/mep_direction (mep-status)
If this variable is read-only (config: false) in the
source YANG file, then _set_mep_direction is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mep_direction() directly.
YANG Description: MEP Direction | f336807:c0:m7 |
def _get_mep_mac(self): | return self.__mep_mac<EOL> | Getter method for mep_mac, mapped from YANG variable /cfm_state/cfm_connectivity/domain/ma/mep/mep_mac (string)
YANG Description: MEP MAC | f336807:c0:m9 |
def _set_mep_mac(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, 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.__mep_mac = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mep_mac, mapped from YANG variable /cfm_state/cfm_connectivity/domain/ma/mep/mep_mac (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_mep_mac is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mep_mac() directly.
YANG Description: MEP MAC | f336807:c0:m10 |
def _get_mep_port(self): | return self.__mep_port<EOL> | Getter method for mep_port, mapped from YANG variable /cfm_state/cfm_connectivity/domain/ma/mep/mep_port (string)
YANG Description: MEP Port | f336807:c0:m12 |
def _set_mep_port(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=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.__mep_port = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mep_port, mapped from YANG variable /cfm_state/cfm_connectivity/domain/ma/mep/mep_port (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_mep_port is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mep_port() directly.
YANG Description: MEP Port | f336807:c0:m13 |
def _get_port_state(self): | return self.__port_state<EOL> | Getter method for port_state, mapped from YANG variable /cfm_state/cfm_connectivity/domain/ma/mep/port_state (uint8)
YANG Description: Port State TLV | f336807:c0:m15 |
def _set_port_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=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, 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_state = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for port_state, mapped from YANG variable /cfm_state/cfm_connectivity/domain/ma/mep/port_state (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_port_state is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_port_state() directly.
YANG Description: Port State TLV | f336807:c0:m16 |
def _get_rmep_fail(self): | return self.__rmep_fail<EOL> | Getter method for rmep_fail, mapped from YANG variable /cfm_state/cfm_connectivity/domain/ma/mep/rmep_fail (uint16)
YANG Description: rmep_fail | f336807:c0:m18 |
def _set_rmep_fail(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=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']},int_size=<NUM_LIT:16>), 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.__rmep_fail = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rmep_fail, mapped from YANG variable /cfm_state/cfm_connectivity/domain/ma/mep/rmep_fail (uint16)
If this variable is read-only (config: false) in the
source YANG file, then _set_rmep_fail is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rmep_fail() directly.
YANG Description: rmep_fail | f336807:c0:m19 |
def _get_rmep_ok(self): | return self.__rmep_ok<EOL> | Getter method for rmep_ok, mapped from YANG variable /cfm_state/cfm_connectivity/domain/ma/mep/rmep_ok (uint16)
YANG Description: rmep_ok | f336807:c0:m21 |
def _set_rmep_ok(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=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']},int_size=<NUM_LIT:16>), 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.__rmep_ok = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rmep_ok, mapped from YANG variable /cfm_state/cfm_connectivity/domain/ma/mep/rmep_ok (uint16)
If this variable is read-only (config: false) in the
source YANG file, then _set_rmep_ok is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rmep_ok() directly.
YANG Description: rmep_ok | f336807:c0:m22 |
def _get_rmep(self): | return self.__rmep<EOL> | Getter method for rmep, mapped from YANG variable /cfm_state/cfm_connectivity/domain/ma/mep/rmep (list)
YANG Description: RMEP Details | f336807:c0:m24 |
def _set_rmep(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>",rmep.rmep, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT>', extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}), is_container='<STR_LIT:list>', yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:list>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__rmep = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rmep, mapped from YANG variable /cfm_state/cfm_connectivity/domain/ma/mep/rmep (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_rmep is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rmep() directly.
YANG Description: RMEP Details | f336807:c0:m25 |
def _get_vlan_id(self): | return self.__vlan_id<EOL> | Getter method for vlan_id, mapped from YANG variable /cfm_state/cfm_connectivity/domain/ma/mip/vlan_id (uint32)
YANG Description: VLAN Id | f336808:c0:m3 |
def _set_vlan_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=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, 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.__vlan_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vlan_id, mapped from YANG variable /cfm_state/cfm_connectivity/domain/ma/mip/vlan_id (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_vlan_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vlan_id() directly.
YANG Description: VLAN Id | f336808:c0:m4 |
def _get_port(self): | return self.__port<EOL> | Getter method for port, mapped from YANG variable /cfm_state/cfm_connectivity/domain/ma/mip/port (string)
YANG Description: MIP port | f336808:c0:m6 |
def _set_port(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:port>", rest_name="<STR_LIT:port>", 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.__port = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for port, mapped from YANG variable /cfm_state/cfm_connectivity/domain/ma/mip/port (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_port is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_port() directly.
YANG Description: MIP port | f336808:c0:m7 |
def _get_level(self): | return self.__level<EOL> | Getter method for level, mapped from YANG variable /cfm_state/cfm_connectivity/domain/ma/mip/level (uint8)
YANG Description: MIP Level | f336808:c0:m9 |
def _set_level(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=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, 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.__level = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for level, mapped from YANG variable /cfm_state/cfm_connectivity/domain/ma/mip/level (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_level is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_level() directly.
YANG Description: MIP Level | f336808:c0:m10 |
def _get_mac(self): | return self.__mac<EOL> | Getter method for mac, mapped from YANG variable /cfm_state/cfm_connectivity/domain/ma/mip/mac (string)
YANG Description: MEP MAC | f336808:c0:m12 |
def _set_mac(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=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.__mac = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mac, mapped from YANG variable /cfm_state/cfm_connectivity/domain/ma/mip/mac (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_mac is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mac() directly.
YANG Description: MEP MAC | f336808:c0:m13 |
def _get_ma_name(self): | return self.__ma_name<EOL> | Getter method for ma_name, mapped from YANG variable /cfm_state/cfm_connectivity/domain/ma/ma_name (string)
YANG Description: ma name | f336809:c0:m3 |
def _set_ma_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.__ma_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ma_name, mapped from YANG variable /cfm_state/cfm_connectivity/domain/ma/ma_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_ma_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ma_name() directly.
YANG Description: ma name | f336809:c0:m4 |
def _get_ma_idx(self): | return self.__ma_idx<EOL> | Getter method for ma_idx, mapped from YANG variable /cfm_state/cfm_connectivity/domain/ma/ma_idx (uint16)
YANG Description: ma index | f336809:c0:m6 |
def _set_ma_idx(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=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']},int_size=<NUM_LIT:16>), 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.__ma_idx = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ma_idx, mapped from YANG variable /cfm_state/cfm_connectivity/domain/ma/ma_idx (uint16)
If this variable is read-only (config: false) in the
source YANG file, then _set_ma_idx is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ma_idx() directly.
YANG Description: ma index | f336809:c0:m7 |
def _get_ma_type(self): | return self.__ma_type<EOL> | Getter method for ma_type, mapped from YANG variable /cfm_state/cfm_connectivity/domain/ma/ma_type (uint8)
YANG Description: Bridge Domain or VLAN MA | f336809:c0:m9 |
def _set_ma_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=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, 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.__ma_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ma_type, mapped from YANG variable /cfm_state/cfm_connectivity/domain/ma/ma_type (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_ma_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ma_type() directly.
YANG Description: Bridge Domain or VLAN MA | f336809:c0:m10 |
def _get_ccm_interval(self): | return self.__ccm_interval<EOL> | Getter method for ccm_interval, mapped from YANG variable /cfm_state/cfm_connectivity/domain/ma/ccm_interval (uint32)
YANG Description: CCM Interval | f336809:c0:m12 |
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=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.__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_state/cfm_connectivity/domain/ma/ccm_interval (uint32)
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.
YANG Description: CCM Interval | f336809:c0:m13 |
def _get_vlan_id(self): | return self.__vlan_id<EOL> | Getter method for vlan_id, mapped from YANG variable /cfm_state/cfm_connectivity/domain/ma/vlan_id (uint32)
YANG Description: VLAN Id | f336809:c0:m15 |
def _set_vlan_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=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.__vlan_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vlan_id, mapped from YANG variable /cfm_state/cfm_connectivity/domain/ma/vlan_id (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_vlan_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vlan_id() directly.
YANG Description: VLAN Id | f336809:c0:m16 |
def _get_priority(self): | return self.__priority<EOL> | Getter method for priority, mapped from YANG variable /cfm_state/cfm_connectivity/domain/ma/priority (uint8)
YANG Description: ma priority | f336809:c0:m18 |
def _set_priority(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=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, 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.__priority = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for priority, mapped from YANG variable /cfm_state/cfm_connectivity/domain/ma/priority (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_priority is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_priority() directly.
YANG Description: ma priority | f336809:c0:m19 |
def _get_mep(self): | return self.__mep<EOL> | Getter method for mep, mapped from YANG variable /cfm_state/cfm_connectivity/domain/ma/mep (list)
YANG Description: MEP Details | f336809:c0:m21 |
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>': u'<STR_LIT>', u'<STR_LIT>': None}}), is_container='<STR_LIT:list>', yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:list>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__mep = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mep, mapped from YANG variable /cfm_state/cfm_connectivity/domain/ma/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.
YANG Description: MEP Details | f336809:c0:m22 |
def _get_mip(self): | return self.__mip<EOL> | Getter method for mip, mapped from YANG variable /cfm_state/cfm_connectivity/domain/ma/mip (list)
YANG Description: MIP Details | f336809:c0:m24 |
def _set_mip(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>",mip.mip, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT>', extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}), is_container='<STR_LIT:list>', yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:list>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__mip = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mip, mapped from YANG variable /cfm_state/cfm_connectivity/domain/ma/mip (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_mip is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mip() directly.
YANG Description: MIP Details | f336809:c0:m25 |
def _get_cfm_detail(self): | return self.__cfm_detail<EOL> | Getter method for cfm_detail, mapped from YANG variable /cfm_state/cfm_detail (container)
YANG Description: CFM Details | f336810:c0:m3 |
def _set_cfm_detail(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_detail.cfm_detail, 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>': u'<STR_LIT>', u'<STR_LIT>': None}}, 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.__cfm_detail = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for cfm_detail, mapped from YANG variable /cfm_state/cfm_detail (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_cfm_detail is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_cfm_detail() directly.
YANG Description: CFM Details | f336810:c0:m4 |
def _get_cfm_connectivity(self): | return self.__cfm_connectivity<EOL> | Getter method for cfm_connectivity, mapped from YANG variable /cfm_state/cfm_connectivity (container)
YANG Description: CFM Connectivity Details | f336810:c0:m6 |
def _set_cfm_connectivity(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_connectivity.cfm_connectivity, 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>': u'<STR_LIT>', u'<STR_LIT>': None}}, 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.__cfm_connectivity = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for cfm_connectivity, mapped from YANG variable /cfm_state/cfm_connectivity (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_cfm_connectivity is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_cfm_connectivity() directly.
YANG Description: CFM Connectivity Details | f336810:c0:m7 |
def _get_rmep_id(self): | return self.__rmep_id<EOL> | Getter method for rmep_id, mapped from YANG variable /cfm_state/cfm_detail/domain/ma/mep/rmep/rmep_id (uint16)
YANG Description: rmep id | f336811:c0:m3 |
def _set_rmep_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:16>), 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.__rmep_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rmep_id, mapped from YANG variable /cfm_state/cfm_detail/domain/ma/mep/rmep/rmep_id (uint16)
If this variable is read-only (config: false) in the
source YANG file, then _set_rmep_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rmep_id() directly.
YANG Description: rmep id | f336811:c0:m4 |
def _get_rmep_mac(self): | return self.__rmep_mac<EOL> | Getter method for rmep_mac, mapped from YANG variable /cfm_state/cfm_detail/domain/ma/mep/rmep/rmep_mac (string)
YANG Description: RMEP MAC | f336811:c0:m6 |
def _set_rmep_mac(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, 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.__rmep_mac = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rmep_mac, mapped from YANG variable /cfm_state/cfm_detail/domain/ma/mep/rmep/rmep_mac (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_rmep_mac is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rmep_mac() directly.
YANG Description: RMEP MAC | f336811:c0:m7 |
def _get_vlan_id(self): | return self.__vlan_id<EOL> | Getter method for vlan_id, mapped from YANG variable /cfm_state/cfm_detail/domain/ma/mep/rmep/vlan_id (uint32)
YANG Description: VLAN Id | f336811:c0:m9 |
def _set_vlan_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=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.__vlan_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vlan_id, mapped from YANG variable /cfm_state/cfm_detail/domain/ma/mep/rmep/vlan_id (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_vlan_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vlan_id() directly.
YANG Description: VLAN Id | f336811:c0:m10 |
def _get_rmep_port(self): | return self.__rmep_port<EOL> | Getter method for rmep_port, mapped from YANG variable /cfm_state/cfm_detail/domain/ma/mep/rmep/rmep_port (string)
YANG Description: RMEP Port | f336811:c0:m12 |
def _set_rmep_port(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=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.__rmep_port = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rmep_port, mapped from YANG variable /cfm_state/cfm_detail/domain/ma/mep/rmep/rmep_port (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_rmep_port is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rmep_port() directly.
YANG Description: RMEP Port | f336811:c0:m13 |
def _get_rmep_state(self): | return self.__rmep_state<EOL> | Getter method for rmep_state, mapped from YANG variable /cfm_state/cfm_detail/domain/ma/mep/rmep/rmep_state (uint8)
YANG Description: RMEP State | f336811:c0:m15 |
def _set_rmep_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=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, 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.__rmep_state = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rmep_state, mapped from YANG variable /cfm_state/cfm_detail/domain/ma/mep/rmep/rmep_state (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_rmep_state is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rmep_state() directly.
YANG Description: RMEP State | f336811:c0:m16 |
def _get_mep_id(self): | return self.__mep_id<EOL> | Getter method for mep_id, mapped from YANG variable /cfm_state/cfm_detail/domain/ma/mep/mep_id (uint16)
YANG Description: mep id | f336812: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=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']},int_size=<NUM_LIT:16>), 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.__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_state/cfm_detail/domain/ma/mep/mep_id (uint16)
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.
YANG Description: mep id | f336812:c0:m4 |
def _get_mep_direction(self): | return self.__mep_direction<EOL> | Getter method for mep_direction, mapped from YANG variable /cfm_state/cfm_detail/domain/ma/mep/mep_direction (mep-status)
YANG Description: MEP Direction | f336812:c0:m6 |
def _set_mep_direction(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>': {'<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, 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.__mep_direction = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mep_direction, mapped from YANG variable /cfm_state/cfm_detail/domain/ma/mep/mep_direction (mep-status)
If this variable is read-only (config: false) in the
source YANG file, then _set_mep_direction is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mep_direction() directly.
YANG Description: MEP Direction | f336812:c0:m7 |
def _get_mep_mac(self): | return self.__mep_mac<EOL> | Getter method for mep_mac, mapped from YANG variable /cfm_state/cfm_detail/domain/ma/mep/mep_mac (string)
YANG Description: MEP MAC | f336812:c0:m9 |
def _set_mep_mac(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, 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.__mep_mac = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mep_mac, mapped from YANG variable /cfm_state/cfm_detail/domain/ma/mep/mep_mac (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_mep_mac is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mep_mac() directly.
YANG Description: MEP MAC | f336812:c0:m10 |
def _get_mep_port(self): | return self.__mep_port<EOL> | Getter method for mep_port, mapped from YANG variable /cfm_state/cfm_detail/domain/ma/mep/mep_port (string)
YANG Description: MEP Port | f336812:c0:m12 |
def _set_mep_port(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=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.__mep_port = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mep_port, mapped from YANG variable /cfm_state/cfm_detail/domain/ma/mep/mep_port (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_mep_port is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mep_port() directly.
YANG Description: MEP Port | f336812:c0:m13 |
def _get_port_state(self): | return self.__port_state<EOL> | Getter method for port_state, mapped from YANG variable /cfm_state/cfm_detail/domain/ma/mep/port_state (uint8)
YANG Description: Port State TLV | f336812:c0:m15 |
def _set_port_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=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, 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_state = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for port_state, mapped from YANG variable /cfm_state/cfm_detail/domain/ma/mep/port_state (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_port_state is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_port_state() directly.
YANG Description: Port State TLV | f336812:c0:m16 |
def _get_rmep_fail(self): | return self.__rmep_fail<EOL> | Getter method for rmep_fail, mapped from YANG variable /cfm_state/cfm_detail/domain/ma/mep/rmep_fail (uint16)
YANG Description: rmep_fail | f336812:c0:m18 |
def _set_rmep_fail(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=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']},int_size=<NUM_LIT:16>), 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.__rmep_fail = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rmep_fail, mapped from YANG variable /cfm_state/cfm_detail/domain/ma/mep/rmep_fail (uint16)
If this variable is read-only (config: false) in the
source YANG file, then _set_rmep_fail is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rmep_fail() directly.
YANG Description: rmep_fail | f336812:c0:m19 |
def _get_rmep_ok(self): | return self.__rmep_ok<EOL> | Getter method for rmep_ok, mapped from YANG variable /cfm_state/cfm_detail/domain/ma/mep/rmep_ok (uint16)
YANG Description: rmep_ok | f336812:c0:m21 |
def _set_rmep_ok(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=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']},int_size=<NUM_LIT:16>), 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.__rmep_ok = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rmep_ok, mapped from YANG variable /cfm_state/cfm_detail/domain/ma/mep/rmep_ok (uint16)
If this variable is read-only (config: false) in the
source YANG file, then _set_rmep_ok is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rmep_ok() directly.
YANG Description: rmep_ok | f336812:c0:m22 |
def _get_rmep(self): | return self.__rmep<EOL> | Getter method for rmep, mapped from YANG variable /cfm_state/cfm_detail/domain/ma/mep/rmep (list)
YANG Description: RMEP Details | f336812:c0:m24 |
def _set_rmep(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>",rmep.rmep, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT>', extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}), is_container='<STR_LIT:list>', yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:list>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__rmep = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rmep, mapped from YANG variable /cfm_state/cfm_detail/domain/ma/mep/rmep (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_rmep is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rmep() directly.
YANG Description: RMEP Details | f336812:c0:m25 |
def _get_vlan_id(self): | return self.__vlan_id<EOL> | Getter method for vlan_id, mapped from YANG variable /cfm_state/cfm_detail/domain/ma/mip/vlan_id (uint32)
YANG Description: VLAN Id | f336813:c0:m3 |
def _set_vlan_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=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, 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.__vlan_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vlan_id, mapped from YANG variable /cfm_state/cfm_detail/domain/ma/mip/vlan_id (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_vlan_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vlan_id() directly.
YANG Description: VLAN Id | f336813:c0:m4 |
def _get_port(self): | return self.__port<EOL> | Getter method for port, mapped from YANG variable /cfm_state/cfm_detail/domain/ma/mip/port (string)
YANG Description: MIP port | f336813:c0:m6 |
def _set_port(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:port>", rest_name="<STR_LIT:port>", 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.__port = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for port, mapped from YANG variable /cfm_state/cfm_detail/domain/ma/mip/port (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_port is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_port() directly.
YANG Description: MIP port | f336813:c0:m7 |
def _get_level(self): | return self.__level<EOL> | Getter method for level, mapped from YANG variable /cfm_state/cfm_detail/domain/ma/mip/level (uint8)
YANG Description: MIP Level | f336813:c0:m9 |
def _set_level(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=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, 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.__level = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for level, mapped from YANG variable /cfm_state/cfm_detail/domain/ma/mip/level (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_level is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_level() directly.
YANG Description: MIP Level | f336813:c0:m10 |
def _get_mac(self): | return self.__mac<EOL> | Getter method for mac, mapped from YANG variable /cfm_state/cfm_detail/domain/ma/mip/mac (string)
YANG Description: MEP MAC | f336813:c0:m12 |
def _set_mac(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=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.__mac = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mac, mapped from YANG variable /cfm_state/cfm_detail/domain/ma/mip/mac (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_mac is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mac() directly.
YANG Description: MEP MAC | f336813:c0:m13 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.