signature stringlengths 8 3.44k | body stringlengths 0 1.41M | docstring stringlengths 1 122k | id stringlengths 5 17 |
|---|---|---|---|
def _get_ptp_port_count(self): | return self.__ptp_port_count<EOL> | Getter method for ptp_port_count, mapped from YANG variable /ptp_state/clock/ptp_port_count (uint32) | f336729:c0:m15 |
def _set_ptp_port_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.__ptp_port_count = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ptp_port_count, mapped from YANG variable /ptp_state/clock/ptp_port_count (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_ptp_port_count is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ptp_port_count() directly. | f336729:c0:m16 |
def _get_priority1(self): | return self.__priority1<EOL> | Getter method for priority1, mapped from YANG variable /ptp_state/clock/priority1 (uint8) | f336729:c0:m18 |
def _set_priority1(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.__priority1 = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for priority1, mapped from YANG variable /ptp_state/clock/priority1 (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_priority1 is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_priority1() directly. | f336729:c0:m19 |
def _get_priority2(self): | return self.__priority2<EOL> | Getter method for priority2, mapped from YANG variable /ptp_state/clock/priority2 (uint8) | f336729:c0:m21 |
def _set_priority2(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.__priority2 = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for priority2, mapped from YANG variable /ptp_state/clock/priority2 (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_priority2 is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_priority2() directly. | f336729:c0:m22 |
def _get_offset_from_master(self): | return self.__offset_from_master<EOL> | Getter method for offset_from_master, mapped from YANG variable /ptp_state/clock/offset_from_master (string) | f336729:c0:m24 |
def _set_offset_from_master(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.__offset_from_master = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for offset_from_master, mapped from YANG variable /ptp_state/clock/offset_from_master (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_offset_from_master is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_offset_from_master() directly. | f336729:c0:m25 |
def _get_mpd(self): | return self.__mpd<EOL> | Getter method for mpd, mapped from YANG variable /ptp_state/clock/mpd (string) | f336729:c0:m27 |
def _set_mpd(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.__mpd = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mpd, mapped from YANG variable /ptp_state/clock/mpd (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_mpd is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mpd() directly. | f336729:c0:m28 |
def _get_steps_removed(self): | return self.__steps_removed<EOL> | Getter method for steps_removed, mapped from YANG variable /ptp_state/clock/steps_removed (uint32) | f336729:c0:m30 |
def _set_steps_removed(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.__steps_removed = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for steps_removed, mapped from YANG variable /ptp_state/clock/steps_removed (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_steps_removed is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_steps_removed() directly. | f336729:c0:m31 |
def _get_local_time(self): | return self.__local_time<EOL> | Getter method for local_time, mapped from YANG variable /ptp_state/clock/local_time (string) | f336729:c0:m33 |
def _set_local_time(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__local_time = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for local_time, mapped from YANG variable /ptp_state/clock/local_time (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_local_time is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_local_time() directly. | f336729:c0:m34 |
def _get_quality(self): | return self.__quality<EOL> | Getter method for quality, mapped from YANG variable /ptp_state/clock/quality (container) | f336729:c0:m36 |
def _set_quality(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=quality.quality, 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.__quality = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for quality, mapped from YANG variable /ptp_state/clock/quality (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_quality is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_quality() directly. | f336729:c0:m37 |
def _get_clock_class(self): | return self.__clock_class<EOL> | Getter method for clock_class, mapped from YANG variable /ptp_state/clock/quality/clock_class (uint32) | f336730:c0:m3 |
def _set_clock_class(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.__clock_class = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for clock_class, mapped from YANG variable /ptp_state/clock/quality/clock_class (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_clock_class is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_clock_class() directly. | f336730:c0:m4 |
def _get_accuracy(self): | return self.__accuracy<EOL> | Getter method for accuracy, mapped from YANG variable /ptp_state/clock/quality/accuracy (uint32) | f336730:c0:m6 |
def _set_accuracy(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.__accuracy = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for accuracy, mapped from YANG variable /ptp_state/clock/quality/accuracy (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_accuracy is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_accuracy() directly. | f336730:c0:m7 |
def _get_offset(self): | return self.__offset<EOL> | Getter method for offset, mapped from YANG variable /ptp_state/clock/quality/offset (uint32) | f336730:c0:m9 |
def _set_offset(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.__offset = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for offset, mapped from YANG variable /ptp_state/clock/quality/offset (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_offset is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_offset() directly. | f336730:c0:m10 |
def _get_utc_offset_valid(self): | return self.__utc_offset_valid<EOL> | Getter method for utc_offset_valid, mapped from YANG variable /ptp_state/time_property/utc_offset_valid (uint32) | f336731:c0:m3 |
def _set_utc_offset_valid(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.__utc_offset_valid = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for utc_offset_valid, mapped from YANG variable /ptp_state/time_property/utc_offset_valid (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_utc_offset_valid is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_utc_offset_valid() directly. | f336731:c0:m4 |
def _get_utc_offset(self): | return self.__utc_offset<EOL> | Getter method for utc_offset, mapped from YANG variable /ptp_state/time_property/utc_offset (uint32) | f336731:c0:m6 |
def _set_utc_offset(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.__utc_offset = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for utc_offset, mapped from YANG variable /ptp_state/time_property/utc_offset (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_utc_offset is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_utc_offset() directly. | f336731:c0:m7 |
def _get_leap59(self): | return self.__leap59<EOL> | Getter method for leap59, mapped from YANG variable /ptp_state/time_property/leap59 (uint32) | f336731:c0:m9 |
def _set_leap59(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.__leap59 = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for leap59, mapped from YANG variable /ptp_state/time_property/leap59 (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_leap59 is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_leap59() directly. | f336731:c0:m10 |
def _get_leap61(self): | return self.__leap61<EOL> | Getter method for leap61, mapped from YANG variable /ptp_state/time_property/leap61 (uint32) | f336731:c0:m12 |
def _set_leap61(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.__leap61 = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for leap61, mapped from YANG variable /ptp_state/time_property/leap61 (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_leap61 is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_leap61() directly. | f336731:c0:m13 |
def _get_time_traceable(self): | return self.__time_traceable<EOL> | Getter method for time_traceable, mapped from YANG variable /ptp_state/time_property/time_traceable (uint32) | f336731:c0:m15 |
def _set_time_traceable(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__time_traceable = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for time_traceable, mapped from YANG variable /ptp_state/time_property/time_traceable (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_time_traceable is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_time_traceable() directly. | f336731:c0:m16 |
def _get_frequency_traceable(self): | return self.__frequency_traceable<EOL> | Getter method for frequency_traceable, mapped from YANG variable /ptp_state/time_property/frequency_traceable (uint32) | f336731:c0:m18 |
def _set_frequency_traceable(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.__frequency_traceable = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for frequency_traceable, mapped from YANG variable /ptp_state/time_property/frequency_traceable (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_frequency_traceable is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_frequency_traceable() directly. | f336731:c0:m19 |
def _get_timescale(self): | return self.__timescale<EOL> | Getter method for timescale, mapped from YANG variable /ptp_state/time_property/timescale (uint32) | f336731:c0:m21 |
def _set_timescale(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.__timescale = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for timescale, mapped from YANG variable /ptp_state/time_property/timescale (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_timescale is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_timescale() directly. | f336731:c0:m22 |
def _get_timesource(self): | return self.__timesource<EOL> | Getter method for timesource, mapped from YANG variable /ptp_state/time_property/timesource (string) | f336731:c0:m24 |
def _set_timesource(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.__timesource = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for timesource, mapped from YANG variable /ptp_state/time_property/timesource (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_timesource is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_timesource() directly. | f336731:c0:m25 |
def _get_brief(self): | return self.__brief<EOL> | Getter method for brief, mapped from YANG variable /ptp_state/brief (container) | f336732:c0:m3 |
def _set_brief(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=brief.brief, 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.__brief = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for brief, mapped from YANG variable /ptp_state/brief (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_brief is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_brief() directly. | f336732:c0:m4 |
def _get_clock(self): | return self.__clock<EOL> | Getter method for clock, mapped from YANG variable /ptp_state/clock (container) | f336732:c0:m6 |
def _set_clock(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=clock.clock, 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.__clock = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for clock, mapped from YANG variable /ptp_state/clock (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_clock is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_clock() directly. | f336732:c0:m7 |
def _get_clock_foreign_masters(self): | return self.__clock_foreign_masters<EOL> | Getter method for clock_foreign_masters, mapped from YANG variable /ptp_state/clock_foreign_masters (container) | f336732:c0:m9 |
def _set_clock_foreign_masters(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=clock_foreign_masters.clock_foreign_masters, 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.__clock_foreign_masters = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for clock_foreign_masters, mapped from YANG variable /ptp_state/clock_foreign_masters (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_clock_foreign_masters is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_clock_foreign_masters() directly. | f336732:c0:m10 |
def _get_corrections(self): | return self.__corrections<EOL> | Getter method for corrections, mapped from YANG variable /ptp_state/corrections (container) | f336732:c0:m12 |
def _set_corrections(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=corrections.corrections, 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.__corrections = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for corrections, mapped from YANG variable /ptp_state/corrections (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_corrections is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_corrections() directly. | f336732:c0:m13 |
def _get_parent_port_detail(self): | return self.__parent_port_detail<EOL> | Getter method for parent_port_detail, mapped from YANG variable /ptp_state/parent_port_detail (container) | f336732:c0:m15 |
def _set_parent_port_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=parent_port_detail.parent_port_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.__parent_port_detail = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for parent_port_detail, mapped from YANG variable /ptp_state/parent_port_detail (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_parent_port_detail is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_parent_port_detail() directly. | f336732:c0:m16 |
def _get_time_property(self): | return self.__time_property<EOL> | Getter method for time_property, mapped from YANG variable /ptp_state/time_property (container) | f336732:c0:m18 |
def _set_time_property(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=time_property.time_property, 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.__time_property = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for time_property, mapped from YANG variable /ptp_state/time_property (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_time_property is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_time_property() directly. | f336732:c0:m19 |
def _get_interfaces_detail(self): | return self.__interfaces_detail<EOL> | Getter method for interfaces_detail, mapped from YANG variable /ptp_state/interfaces_detail (list) | f336732:c0:m21 |
def _set_interfaces_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=YANGListType("<STR_LIT>",interfaces_detail.interfaces_detail, 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.__interfaces_detail = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for interfaces_detail, mapped from YANG variable /ptp_state/interfaces_detail (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_interfaces_detail is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_interfaces_detail() directly. | f336732:c0:m22 |
def _get_port(self): | return self.__port<EOL> | Getter method for port, mapped from YANG variable /ptp_state/brief/port_detail_list/port (string) | f336733:c0:m3 |
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 /ptp_state/brief/port_detail_list/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. | f336733:c0:m4 |
def _get_ptp_state(self): | return self.__ptp_state<EOL> | Getter method for ptp_state, mapped from YANG variable /ptp_state/brief/port_detail_list/ptp_state (string) | f336733:c0:m6 |
def _set_ptp_state(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__ptp_state = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ptp_state, mapped from YANG variable /ptp_state/brief/port_detail_list/ptp_state (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_ptp_state is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ptp_state() directly. | f336733:c0:m7 |
def _get_port_detail_list(self): | return self.__port_detail_list<EOL> | Getter method for port_detail_list, mapped from YANG variable /ptp_state/brief/port_detail_list (list) | f336734:c0:m3 |
def _set_port_detail_list(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGListType("<STR_LIT:port>",port_detail_list.port_detail_list, 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:port>', 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.__port_detail_list = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for port_detail_list, mapped from YANG variable /ptp_state/brief/port_detail_list (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_port_detail_list is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_port_detail_list() directly. | f336734:c0:m4 |
def _get_slave_port(self): | return self.__slave_port<EOL> | Getter method for slave_port, mapped from YANG variable /ptp_state/corrections/correction_detail_list/slave_port (string) | f336735:c0:m3 |
def _set_slave_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>", 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.__slave_port = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for slave_port, mapped from YANG variable /ptp_state/corrections/correction_detail_list/slave_port (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_slave_port is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_slave_port() directly. | f336735:c0:m4 |
def _get_sup_time(self): | return self.__sup_time<EOL> | Getter method for sup_time, mapped from YANG variable /ptp_state/corrections/correction_detail_list/sup_time (string) | f336735:c0:m6 |
def _set_sup_time(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.__sup_time = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for sup_time, mapped from YANG variable /ptp_state/corrections/correction_detail_list/sup_time (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_sup_time is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_sup_time() directly. | f336735:c0:m7 |
def _get_correction(self): | return self.__correction<EOL> | Getter method for correction, mapped from YANG variable /ptp_state/corrections/correction_detail_list/correction (int32) | f336735:c0:m9 |
def _set_correction(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.__correction = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for correction, mapped from YANG variable /ptp_state/corrections/correction_detail_list/correction (int32)
If this variable is read-only (config: false) in the
source YANG file, then _set_correction is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_correction() directly. | f336735:c0:m10 |
def _get_correction_detail_list(self): | return self.__correction_detail_list<EOL> | Getter method for correction_detail_list, mapped from YANG variable /ptp_state/corrections/correction_detail_list (list) | f336736:c0:m3 |
def _set_correction_detail_list(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGListType("<STR_LIT>",correction_detail_list.correction_detail_list, 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.__correction_detail_list = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for correction_detail_list, mapped from YANG variable /ptp_state/corrections/correction_detail_list (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_correction_detail_list is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_correction_detail_list() directly. | f336736:c0:m4 |
def _get_parent_clock_identity(self): | return self.__parent_clock_identity<EOL> | Getter method for parent_clock_identity, mapped from YANG variable /ptp_state/parent_port_detail/parent_clock_identity (string) | f336737:c0:m3 |
def _set_parent_clock_identity(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.__parent_clock_identity = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for parent_clock_identity, mapped from YANG variable /ptp_state/parent_port_detail/parent_clock_identity (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_parent_clock_identity is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_parent_clock_identity() directly. | f336737:c0:m4 |
def _get_parent_port_number(self): | return self.__parent_port_number<EOL> | Getter method for parent_port_number, mapped from YANG variable /ptp_state/parent_port_detail/parent_port_number (uint32) | f336737:c0:m6 |
def _set_parent_port_number(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.__parent_port_number = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for parent_port_number, mapped from YANG variable /ptp_state/parent_port_detail/parent_port_number (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_parent_port_number is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_parent_port_number() directly. | f336737:c0:m7 |
def _get_parent_ip_address(self): | return self.__parent_ip_address<EOL> | Getter method for parent_ip_address, mapped from YANG variable /ptp_state/parent_port_detail/parent_ip_address (string) | f336737:c0:m9 |
def _set_parent_ip_address(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.__parent_ip_address = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for parent_ip_address, mapped from YANG variable /ptp_state/parent_port_detail/parent_ip_address (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_parent_ip_address is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_parent_ip_address() directly. | f336737:c0:m10 |
def _get_parent_offset(self): | return self.__parent_offset<EOL> | Getter method for parent_offset, mapped from YANG variable /ptp_state/parent_port_detail/parent_offset (int32) | f336737:c0:m12 |
def _set_parent_offset(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.__parent_offset = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for parent_offset, mapped from YANG variable /ptp_state/parent_port_detail/parent_offset (int32)
If this variable is read-only (config: false) in the
source YANG file, then _set_parent_offset is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_parent_offset() directly. | f336737:c0:m13 |
def _get_parent_cpcr(self): | return self.__parent_cpcr<EOL> | Getter method for parent_cpcr, mapped from YANG variable /ptp_state/parent_port_detail/parent_cpcr (int32) | f336737:c0:m15 |
def _set_parent_cpcr(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.__parent_cpcr = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for parent_cpcr, mapped from YANG variable /ptp_state/parent_port_detail/parent_cpcr (int32)
If this variable is read-only (config: false) in the
source YANG file, then _set_parent_cpcr is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_parent_cpcr() directly. | f336737:c0:m16 |
def _get_grandparent_identity(self): | return self.__grandparent_identity<EOL> | Getter method for grandparent_identity, mapped from YANG variable /ptp_state/parent_port_detail/grandparent_identity (string) | f336737:c0:m18 |
def _set_grandparent_identity(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.__grandparent_identity = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for grandparent_identity, mapped from YANG variable /ptp_state/parent_port_detail/grandparent_identity (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_grandparent_identity is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_grandparent_identity() directly. | f336737:c0:m19 |
def _get_grandparent_quality_class(self): | return self.__grandparent_quality_class<EOL> | Getter method for grandparent_quality_class, mapped from YANG variable /ptp_state/parent_port_detail/grandparent_quality_class (uint32) | f336737:c0:m21 |
def _set_grandparent_quality_class(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.__grandparent_quality_class = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for grandparent_quality_class, mapped from YANG variable /ptp_state/parent_port_detail/grandparent_quality_class (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_grandparent_quality_class is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_grandparent_quality_class() directly. | f336737:c0:m22 |
def _get_grandparent_quality_accuracy(self): | return self.__grandparent_quality_accuracy<EOL> | Getter method for grandparent_quality_accuracy, mapped from YANG variable /ptp_state/parent_port_detail/grandparent_quality_accuracy (uint32) | f336737:c0:m24 |
def _set_grandparent_quality_accuracy(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.__grandparent_quality_accuracy = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for grandparent_quality_accuracy, mapped from YANG variable /ptp_state/parent_port_detail/grandparent_quality_accuracy (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_grandparent_quality_accuracy is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_grandparent_quality_accuracy() directly. | f336737:c0:m25 |
def _get_grandparent_quality_oslv(self): | return self.__grandparent_quality_oslv<EOL> | Getter method for grandparent_quality_oslv, mapped from YANG variable /ptp_state/parent_port_detail/grandparent_quality_oslv (uint32) | f336737:c0:m27 |
def _set_grandparent_quality_oslv(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.__grandparent_quality_oslv = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for grandparent_quality_oslv, mapped from YANG variable /ptp_state/parent_port_detail/grandparent_quality_oslv (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_grandparent_quality_oslv is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_grandparent_quality_oslv() directly. | f336737:c0:m28 |
def _get_grandparent_quality_priority1(self): | return self.__grandparent_quality_priority1<EOL> | Getter method for grandparent_quality_priority1, mapped from YANG variable /ptp_state/parent_port_detail/grandparent_quality_priority1 (uint32) | f336737:c0:m30 |
def _set_grandparent_quality_priority1(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.__grandparent_quality_priority1 = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for grandparent_quality_priority1, mapped from YANG variable /ptp_state/parent_port_detail/grandparent_quality_priority1 (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_grandparent_quality_priority1 is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_grandparent_quality_priority1() directly. | f336737:c0:m31 |
def _get_grandparent_quality_priority2(self): | return self.__grandparent_quality_priority2<EOL> | Getter method for grandparent_quality_priority2, mapped from YANG variable /ptp_state/parent_port_detail/grandparent_quality_priority2 (uint32) | f336737:c0:m33 |
def _set_grandparent_quality_priority2(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.__grandparent_quality_priority2 = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for grandparent_quality_priority2, mapped from YANG variable /ptp_state/parent_port_detail/grandparent_quality_priority2 (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_grandparent_quality_priority2 is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_grandparent_quality_priority2() directly. | f336737:c0:m34 |
def _get_id(self): | return self.__id<EOL> | Getter method for id, mapped from YANG variable /ptp_state/interfaces_detail/interface_detail_list/id (string) | f336738:c0:m3 |
def _set_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=unicode, is_leaf=True, yang_name="<STR_LIT:id>", rest_name="<STR_LIT:id>", 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.__id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for id, mapped from YANG variable /ptp_state/interfaces_detail/interface_detail_list/id (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_id() directly. | f336738:c0:m4 |
def _get_port_dataset(self): | return self.__port_dataset<EOL> | Getter method for port_dataset, mapped from YANG variable /ptp_state/interfaces_detail/interface_detail_list/port_dataset (string) | f336738:c0:m6 |
def _set_port_dataset(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.__port_dataset = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for port_dataset, mapped from YANG variable /ptp_state/interfaces_detail/interface_detail_list/port_dataset (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_port_dataset is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_port_dataset() directly. | f336738:c0:m7 |
def _get_clock_identity(self): | return self.__clock_identity<EOL> | Getter method for clock_identity, mapped from YANG variable /ptp_state/interfaces_detail/interface_detail_list/clock_identity (string) | f336738:c0:m9 |
def _set_clock_identity(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.__clock_identity = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for clock_identity, mapped from YANG variable /ptp_state/interfaces_detail/interface_detail_list/clock_identity (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_clock_identity is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_clock_identity() directly. | f336738:c0:m10 |
def _get_port_number(self): | return self.__port_number<EOL> | Getter method for port_number, mapped from YANG variable /ptp_state/interfaces_detail/interface_detail_list/port_number (uint32) | f336738:c0:m12 |
def _set_port_number(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.__port_number = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for port_number, mapped from YANG variable /ptp_state/interfaces_detail/interface_detail_list/port_number (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_port_number is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_port_number() directly. | f336738:c0:m13 |
def _get_ptp_version(self): | return self.__ptp_version<EOL> | Getter method for ptp_version, mapped from YANG variable /ptp_state/interfaces_detail/interface_detail_list/ptp_version (uint16) | f336738:c0:m15 |
def _set_ptp_version(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.__ptp_version = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ptp_version, mapped from YANG variable /ptp_state/interfaces_detail/interface_detail_list/ptp_version (uint16)
If this variable is read-only (config: false) in the
source YANG file, then _set_ptp_version is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ptp_version() directly. | f336738:c0:m16 |
def _get_port_state(self): | return self.__port_state<EOL> | Getter method for port_state, mapped from YANG variable /ptp_state/interfaces_detail/interface_detail_list/port_state (string) | f336738:c0:m18 |
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=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.__port_state = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for port_state, mapped from YANG variable /ptp_state/interfaces_detail/interface_detail_list/port_state (string)
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. | f336738:c0:m19 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.