signature stringlengths 8 3.44k | body stringlengths 0 1.41M | docstring stringlengths 1 122k | id stringlengths 5 17 |
|---|---|---|---|
def _get_scheduler_type(self): | return self.__scheduler_type<EOL> | Getter method for scheduler_type, mapped from YANG variable /policy_map/class/scheduler/strict_priority/scheduler_type (enumeration) | f336492:c0:m6 |
def _set_scheduler_type(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}},), 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}}, 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.__scheduler_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for scheduler_type, mapped from YANG variable /policy_map/class/scheduler/strict_priority/scheduler_type (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_scheduler_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_scheduler_type() directly. | f336492:c0:m7 |
def _get_dwrr_traffic_class0(self): | return self.__dwrr_traffic_class0<EOL> | Getter method for dwrr_traffic_class0, mapped from YANG variable /policy_map/class/scheduler/strict_priority/dwrr_traffic_class0 (uint32) | f336492:c0:m9 |
def _set_dwrr_traffic_class0(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT>': 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.__dwrr_traffic_class0 = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for dwrr_traffic_class0, mapped from YANG variable /policy_map/class/scheduler/strict_priority/dwrr_traffic_class0 (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_dwrr_traffic_class0 is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_dwrr_traffic_class0() directly. | f336492:c0:m10 |
def _get_dwrr_traffic_class1(self): | return self.__dwrr_traffic_class1<EOL> | Getter method for dwrr_traffic_class1, mapped from YANG variable /policy_map/class/scheduler/strict_priority/dwrr_traffic_class1 (uint32) | f336492:c0:m12 |
def _set_dwrr_traffic_class1(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT>': 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.__dwrr_traffic_class1 = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for dwrr_traffic_class1, mapped from YANG variable /policy_map/class/scheduler/strict_priority/dwrr_traffic_class1 (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_dwrr_traffic_class1 is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_dwrr_traffic_class1() directly. | f336492:c0:m13 |
def _get_dwrr_traffic_class2(self): | return self.__dwrr_traffic_class2<EOL> | Getter method for dwrr_traffic_class2, mapped from YANG variable /policy_map/class/scheduler/strict_priority/dwrr_traffic_class2 (uint32) | f336492:c0:m15 |
def _set_dwrr_traffic_class2(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT>': 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.__dwrr_traffic_class2 = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for dwrr_traffic_class2, mapped from YANG variable /policy_map/class/scheduler/strict_priority/dwrr_traffic_class2 (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_dwrr_traffic_class2 is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_dwrr_traffic_class2() directly. | f336492:c0:m16 |
def _get_dwrr_traffic_class3(self): | return self.__dwrr_traffic_class3<EOL> | Getter method for dwrr_traffic_class3, mapped from YANG variable /policy_map/class/scheduler/strict_priority/dwrr_traffic_class3 (uint32) | f336492:c0:m18 |
def _set_dwrr_traffic_class3(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT>': 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.__dwrr_traffic_class3 = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for dwrr_traffic_class3, mapped from YANG variable /policy_map/class/scheduler/strict_priority/dwrr_traffic_class3 (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_dwrr_traffic_class3 is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_dwrr_traffic_class3() directly. | f336492:c0:m19 |
def _get_dwrr_traffic_class4(self): | return self.__dwrr_traffic_class4<EOL> | Getter method for dwrr_traffic_class4, mapped from YANG variable /policy_map/class/scheduler/strict_priority/dwrr_traffic_class4 (uint32) | f336492:c0:m21 |
def _set_dwrr_traffic_class4(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT>': 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.__dwrr_traffic_class4 = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for dwrr_traffic_class4, mapped from YANG variable /policy_map/class/scheduler/strict_priority/dwrr_traffic_class4 (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_dwrr_traffic_class4 is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_dwrr_traffic_class4() directly. | f336492:c0:m22 |
def _get_dwrr_traffic_class5(self): | return self.__dwrr_traffic_class5<EOL> | Getter method for dwrr_traffic_class5, mapped from YANG variable /policy_map/class/scheduler/strict_priority/dwrr_traffic_class5 (uint32) | f336492:c0:m24 |
def _set_dwrr_traffic_class5(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT>': 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.__dwrr_traffic_class5 = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for dwrr_traffic_class5, mapped from YANG variable /policy_map/class/scheduler/strict_priority/dwrr_traffic_class5 (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_dwrr_traffic_class5 is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_dwrr_traffic_class5() directly. | f336492:c0:m25 |
def _get_dwrr_traffic_class6(self): | return self.__dwrr_traffic_class6<EOL> | Getter method for dwrr_traffic_class6, mapped from YANG variable /policy_map/class/scheduler/strict_priority/dwrr_traffic_class6 (uint32) | f336492:c0:m27 |
def _set_dwrr_traffic_class6(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT>': 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.__dwrr_traffic_class6 = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for dwrr_traffic_class6, mapped from YANG variable /policy_map/class/scheduler/strict_priority/dwrr_traffic_class6 (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_dwrr_traffic_class6 is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_dwrr_traffic_class6() directly. | f336492:c0:m28 |
def _get_dwrr_traffic_class_last(self): | return self.__dwrr_traffic_class_last<EOL> | Getter method for dwrr_traffic_class_last, mapped from YANG variable /policy_map/class/scheduler/strict_priority/dwrr_traffic_class_last (uint32) | f336492:c0:m30 |
def _set_dwrr_traffic_class_last(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None}}, 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.__dwrr_traffic_class_last = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for dwrr_traffic_class_last, mapped from YANG variable /policy_map/class/scheduler/strict_priority/dwrr_traffic_class_last (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_dwrr_traffic_class_last is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_dwrr_traffic_class_last() directly. | f336492:c0:m31 |
def _get_TC1(self): | return self.__TC1<EOL> | Getter method for TC1, mapped from YANG variable /policy_map/class/scheduler/strict_priority/TC1 (shaping-rate-limit) | f336492:c0:m33 |
def _set_TC1(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:64>), 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>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__TC1 = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for TC1, mapped from YANG variable /policy_map/class/scheduler/strict_priority/TC1 (shaping-rate-limit)
If this variable is read-only (config: false) in the
source YANG file, then _set_TC1 is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_TC1() directly. | f336492:c0:m34 |
def _get_TC2(self): | return self.__TC2<EOL> | Getter method for TC2, mapped from YANG variable /policy_map/class/scheduler/strict_priority/TC2 (shaping-rate-limit) | f336492:c0:m36 |
def _set_TC2(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:64>), 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>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__TC2 = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for TC2, mapped from YANG variable /policy_map/class/scheduler/strict_priority/TC2 (shaping-rate-limit)
If this variable is read-only (config: false) in the
source YANG file, then _set_TC2 is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_TC2() directly. | f336492:c0:m37 |
def _get_TC3(self): | return self.__TC3<EOL> | Getter method for TC3, mapped from YANG variable /policy_map/class/scheduler/strict_priority/TC3 (shaping-rate-limit) | f336492:c0:m39 |
def _set_TC3(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:64>), 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>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__TC3 = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for TC3, mapped from YANG variable /policy_map/class/scheduler/strict_priority/TC3 (shaping-rate-limit)
If this variable is read-only (config: false) in the
source YANG file, then _set_TC3 is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_TC3() directly. | f336492:c0:m40 |
def _get_TC4(self): | return self.__TC4<EOL> | Getter method for TC4, mapped from YANG variable /policy_map/class/scheduler/strict_priority/TC4 (shaping-rate-limit) | f336492:c0:m42 |
def _set_TC4(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:64>), 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>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__TC4 = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for TC4, mapped from YANG variable /policy_map/class/scheduler/strict_priority/TC4 (shaping-rate-limit)
If this variable is read-only (config: false) in the
source YANG file, then _set_TC4 is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_TC4() directly. | f336492:c0:m43 |
def _get_TC5(self): | return self.__TC5<EOL> | Getter method for TC5, mapped from YANG variable /policy_map/class/scheduler/strict_priority/TC5 (shaping-rate-limit) | f336492:c0:m45 |
def _set_TC5(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:64>), 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>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__TC5 = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for TC5, mapped from YANG variable /policy_map/class/scheduler/strict_priority/TC5 (shaping-rate-limit)
If this variable is read-only (config: false) in the
source YANG file, then _set_TC5 is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_TC5() directly. | f336492:c0:m46 |
def _get_TC6(self): | return self.__TC6<EOL> | Getter method for TC6, mapped from YANG variable /policy_map/class/scheduler/strict_priority/TC6 (shaping-rate-limit) | f336492:c0:m48 |
def _set_TC6(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:64>), 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>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__TC6 = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for TC6, mapped from YANG variable /policy_map/class/scheduler/strict_priority/TC6 (shaping-rate-limit)
If this variable is read-only (config: false) in the
source YANG file, then _set_TC6 is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_TC6() directly. | f336492:c0:m49 |
def _get_TC7(self): | return self.__TC7<EOL> | Getter method for TC7, mapped from YANG variable /policy_map/class/scheduler/strict_priority/TC7 (shaping-rate-limit) | f336492:c0:m51 |
def _set_TC7(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:64>), 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>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__TC7 = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for TC7, mapped from YANG variable /policy_map/class/scheduler/strict_priority/TC7 (shaping-rate-limit)
If this variable is read-only (config: false) in the
source YANG file, then _set_TC7 is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_TC7() directly. | f336492:c0:m52 |
def _get_type(self): | return self.__type<EOL> | Getter method for type, mapped from YANG variable /threshold_monitor_hidden/threshold_monitor/sfp/policy/area/type (enumeration) | f336493:c0:m3 |
def _set_type(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:5>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:11>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:16>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:12>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:9>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:15>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:8>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:10>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:7>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:6>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:0>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:4>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:3>}},), is_leaf=True, yang_name="<STR_LIT:type>", rest_name="<STR_LIT:type>", 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}}, 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.__type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for type, mapped from YANG variable /threshold_monitor_hidden/threshold_monitor/sfp/policy/area/type (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_type() directly. | f336493:c0:m4 |
def _get_area_value(self): | return self.__area_value<EOL> | Getter method for area_value, mapped from YANG variable /threshold_monitor_hidden/threshold_monitor/sfp/policy/area/area_value (enumeration) | f336493:c0:m6 |
def _set_area_value(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:3>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:4>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:0>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None}}, 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.__area_value = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for area_value, mapped from YANG variable /threshold_monitor_hidden/threshold_monitor/sfp/policy/area/area_value (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_area_value is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_area_value() directly. | f336493:c0:m7 |
def _get_threshold(self): | return self.__threshold<EOL> | Getter method for threshold, mapped from YANG variable /threshold_monitor_hidden/threshold_monitor/sfp/policy/area/threshold (container) | f336493:c0:m9 |
def _set_threshold(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=threshold.threshold, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': 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.__threshold = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for threshold, mapped from YANG variable /threshold_monitor_hidden/threshold_monitor/sfp/policy/area/threshold (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_threshold is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_threshold() directly. | f336493:c0:m10 |
def _get_alert(self): | return self.__alert<EOL> | Getter method for alert, mapped from YANG variable /threshold_monitor_hidden/threshold_monitor/sfp/policy/area/alert (container) | f336493:c0:m12 |
def _set_alert(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=alert.alert, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None}}, 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.__alert = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for alert, mapped from YANG variable /threshold_monitor_hidden/threshold_monitor/sfp/policy/area/alert (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_alert is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_alert() directly. | f336493:c0:m13 |
def _get_protocol_status(self): | return self.__protocol_status<EOL> | Getter method for protocol_status, mapped from YANG variable /logical_interface_state/main_interface_physical/protocol_status (boolean)
YANG Description: Protocol Status | f336494:c0:m3 |
def _set_protocol_status(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__protocol_status = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for protocol_status, mapped from YANG variable /logical_interface_state/main_interface_physical/protocol_status (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_protocol_status is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_protocol_status() directly.
YANG Description: Protocol Status | f336494:c0:m4 |
def _get_admin_status(self): | return self.__admin_status<EOL> | Getter method for admin_status, mapped from YANG variable /logical_interface_state/main_interface_physical/admin_status (boolean)
YANG Description: Admin Status | f336494:c0:m6 |
def _set_admin_status(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__admin_status = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for admin_status, mapped from YANG variable /logical_interface_state/main_interface_physical/admin_status (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_admin_status is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_admin_status() directly.
YANG Description: Admin Status | f336494:c0:m7 |
def _get_interface_index(self): | return self.__interface_index<EOL> | Getter method for interface_index, mapped from YANG variable /logical_interface_state/main_interface_physical/interface_index (uint32)
YANG Description: interface index | f336494:c0:m9 |
def _set_interface_index(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__interface_index = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for interface_index, mapped from YANG variable /logical_interface_state/main_interface_physical/interface_index (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_interface_index is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_interface_index() directly.
YANG Description: interface index | f336494:c0:m10 |
def _get_counters(self): | return self.__counters<EOL> | Getter method for counters, mapped from YANG variable /logical_interface_state/main_interface_physical/counters (container)
YANG Description: Lif counters | f336494:c0:m12 |
def _set_counters(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=counters.counters, 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.__counters = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for counters, mapped from YANG variable /logical_interface_state/main_interface_physical/counters (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_counters is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_counters() directly.
YANG Description: Lif counters | f336494:c0:m13 |
def _get_intf_type(self): | return self.__intf_type<EOL> | Getter method for intf_type, mapped from YANG variable /logical_interface_state/main_interface_physical/intf_type (intf-type)
YANG Description: interface type | f336494:c0:m15 |
def _set_intf_type(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:3>}},), 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.__intf_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for intf_type, mapped from YANG variable /logical_interface_state/main_interface_physical/intf_type (intf-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_intf_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_intf_type() directly.
YANG Description: interface type | f336494:c0:m16 |
def _get_intf_name(self): | return self.__intf_name<EOL> | Getter method for intf_name, mapped from YANG variable /logical_interface_state/main_interface_physical/intf_name (string)
YANG Description: main interface name | f336494:c0:m18 |
def _set_intf_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.__intf_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for intf_name, mapped from YANG variable /logical_interface_state/main_interface_physical/intf_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_intf_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_intf_name() directly.
YANG Description: main interface name | f336494:c0:m19 |
def _get_is_tagged(self): | return self.__is_tagged<EOL> | Getter method for is_tagged, mapped from YANG variable /logical_interface_state/main_interface_physical/is_tagged (boolean)
YANG Description: is Lif tagged | f336494:c0:m21 |
def _set_is_tagged(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__is_tagged = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for is_tagged, mapped from YANG variable /logical_interface_state/main_interface_physical/is_tagged (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_is_tagged is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_is_tagged() directly.
YANG Description: is Lif tagged | f336494:c0:m22 |
def _get_port_mode(self): | return self.__port_mode<EOL> | Getter method for port_mode, mapped from YANG variable /logical_interface_state/main_interface_physical/port_mode (string)
YANG Description: port mode | f336494:c0:m24 |
def _set_port_mode(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=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_mode = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for port_mode, mapped from YANG variable /logical_interface_state/main_interface_physical/port_mode (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_port_mode is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_port_mode() directly.
YANG Description: port mode | f336494:c0:m25 |
def _get_logical_interface_physical(self): | return self.__logical_interface_physical<EOL> | Getter method for logical_interface_physical, mapped from YANG variable /logical_interface_state/main_interface_physical/logical_interface_physical (container)
YANG Description: logical interface physical | f336494:c0:m27 |
def _set_logical_interface_physical(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=logical_interface_physical.logical_interface_physical, 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.__logical_interface_physical = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for logical_interface_physical, mapped from YANG variable /logical_interface_state/main_interface_physical/logical_interface_physical (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_logical_interface_physical is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_logical_interface_physical() directly.
YANG Description: logical interface physical | f336494:c0:m28 |
def _get_lif_type(self): | return self.__lif_type<EOL> | Getter method for lif_type, mapped from YANG variable /logical_interface_state/main_interface_physical/counters/lif_type (intf-type)
YANG Description: interface type | f336495:c0:m3 |
def _set_lif_type(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:3>}},), 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.__lif_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for lif_type, mapped from YANG variable /logical_interface_state/main_interface_physical/counters/lif_type (intf-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_lif_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lif_type() directly.
YANG Description: interface type | f336495:c0:m4 |
def _get_total_lifs(self): | return self.__total_lifs<EOL> | Getter method for total_lifs, mapped from YANG variable /logical_interface_state/main_interface_physical/counters/total_lifs (uint32)
YANG Description: total Lifs | f336495:c0:m6 |
def _set_total_lifs(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.__total_lifs = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for total_lifs, mapped from YANG variable /logical_interface_state/main_interface_physical/counters/total_lifs (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_total_lifs is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_total_lifs() directly.
YANG Description: total Lifs | f336495:c0:m7 |
def _get_protocol_status_up_lifs(self): | return self.__protocol_status_up_lifs<EOL> | Getter method for protocol_status_up_lifs, mapped from YANG variable /logical_interface_state/main_interface_physical/counters/protocol_status_up_lifs (uint32)
YANG Description: Protocol status up lifs | f336495:c0:m9 |
def _set_protocol_status_up_lifs(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.__protocol_status_up_lifs = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for protocol_status_up_lifs, mapped from YANG variable /logical_interface_state/main_interface_physical/counters/protocol_status_up_lifs (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_protocol_status_up_lifs is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_protocol_status_up_lifs() directly.
YANG Description: Protocol status up lifs | f336495:c0:m10 |
def _get_binded_lifs(self): | return self.__binded_lifs<EOL> | Getter method for binded_lifs, mapped from YANG variable /logical_interface_state/main_interface_physical/counters/binded_lifs (uint32)
YANG Description: binded lifs | f336495:c0:m12 |
def _set_binded_lifs(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.__binded_lifs = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for binded_lifs, mapped from YANG variable /logical_interface_state/main_interface_physical/counters/binded_lifs (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_binded_lifs is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_binded_lifs() directly.
YANG Description: binded lifs | f336495:c0:m13 |
def _get_unbinded_lifs(self): | return self.__unbinded_lifs<EOL> | Getter method for unbinded_lifs, mapped from YANG variable /logical_interface_state/main_interface_physical/counters/unbinded_lifs (uint32)
YANG Description: unbinded lifs | f336495:c0:m15 |
def _set_unbinded_lifs(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.__unbinded_lifs = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for unbinded_lifs, mapped from YANG variable /logical_interface_state/main_interface_physical/counters/unbinded_lifs (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_unbinded_lifs is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_unbinded_lifs() directly.
YANG Description: unbinded lifs | f336495:c0:m16 |
def _get_implicit_lifs(self): | return self.__implicit_lifs<EOL> | Getter method for implicit_lifs, mapped from YANG variable /logical_interface_state/main_interface_physical/counters/implicit_lifs (uint32)
YANG Description: implicit lifs | f336495:c0:m18 |
def _set_implicit_lifs(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.__implicit_lifs = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for implicit_lifs, mapped from YANG variable /logical_interface_state/main_interface_physical/counters/implicit_lifs (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_implicit_lifs is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_implicit_lifs() directly.
YANG Description: implicit lifs | f336495:c0:m19 |
def _get_explicit_lifs(self): | return self.__explicit_lifs<EOL> | Getter method for explicit_lifs, mapped from YANG variable /logical_interface_state/main_interface_physical/counters/explicit_lifs (uint32)
YANG Description: explicit lifs | f336495:c0:m21 |
def _set_explicit_lifs(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.__explicit_lifs = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for explicit_lifs, mapped from YANG variable /logical_interface_state/main_interface_physical/counters/explicit_lifs (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_explicit_lifs is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_explicit_lifs() directly.
YANG Description: explicit lifs | f336495:c0:m22 |
def _get_logical_interface_name(self): | return self.__logical_interface_name<EOL> | Getter method for logical_interface_name, mapped from YANG variable /logical_interface_state/main_interface_physical/logical_interface_physical/logical_interface_name (string)
YANG Description: Logical Interface name | f336496:c0:m3 |
def _set_logical_interface_name(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=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.__logical_interface_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for logical_interface_name, mapped from YANG variable /logical_interface_state/main_interface_physical/logical_interface_physical/logical_interface_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_logical_interface_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_logical_interface_name() directly.
YANG Description: Logical Interface name | f336496:c0:m4 |
def _get_source_type(self): | return self.__source_type<EOL> | Getter method for source_type, mapped from YANG variable /logical_interface_state/main_interface_physical/logical_interface_physical/source_type (string)
YANG Description: source type | f336496:c0:m6 |
def _set_source_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=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.__source_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for source_type, mapped from YANG variable /logical_interface_state/main_interface_physical/logical_interface_physical/source_type (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_source_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_source_type() directly.
YANG Description: source type | f336496:c0:m7 |
def _get_protocol_status(self): | return self.__protocol_status<EOL> | Getter method for protocol_status, mapped from YANG variable /logical_interface_state/main_interface_physical/logical_interface_physical/protocol_status (boolean)
YANG Description: Protocol Status | f336496:c0:m9 |
def _set_protocol_status(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__protocol_status = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for protocol_status, mapped from YANG variable /logical_interface_state/main_interface_physical/logical_interface_physical/protocol_status (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_protocol_status is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_protocol_status() directly.
YANG Description: Protocol Status | f336496:c0:m10 |
def _get_admin_status(self): | return self.__admin_status<EOL> | Getter method for admin_status, mapped from YANG variable /logical_interface_state/main_interface_physical/logical_interface_physical/admin_status (boolean)
YANG Description: Admin Status | f336496:c0:m12 |
def _set_admin_status(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__admin_status = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for admin_status, mapped from YANG variable /logical_interface_state/main_interface_physical/logical_interface_physical/admin_status (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_admin_status is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_admin_status() directly.
YANG Description: Admin Status | f336496:c0:m13 |
def _get_lif_index(self): | return self.__lif_index<EOL> | Getter method for lif_index, mapped from YANG variable /logical_interface_state/main_interface_physical/logical_interface_physical/lif_index (uint32)
YANG Description: Lif index | f336496:c0:m15 |
def _set_lif_index(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__lif_index = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for lif_index, mapped from YANG variable /logical_interface_state/main_interface_physical/logical_interface_physical/lif_index (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_lif_index is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lif_index() directly.
YANG Description: Lif index | f336496:c0:m16 |
def _get_bridge_domain_index(self): | return self.__bridge_domain_index<EOL> | Getter method for bridge_domain_index, mapped from YANG variable /logical_interface_state/main_interface_physical/logical_interface_physical/bridge_domain_index (uint32)
YANG Description: Bridge Domain index | f336496:c0:m18 |
def _set_bridge_domain_index(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__bridge_domain_index = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for bridge_domain_index, mapped from YANG variable /logical_interface_state/main_interface_physical/logical_interface_physical/bridge_domain_index (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_bridge_domain_index is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_bridge_domain_index() directly.
YANG Description: Bridge Domain index | f336496:c0:m19 |
def _get_interface_name(self): | return self.__interface_name<EOL> | Getter method for interface_name, mapped from YANG variable /logical_interface_state/main_interface_physical/logical_interface_physical/interface_name (string)
YANG Description: interface name | f336496:c0:m21 |
def _set_interface_name(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=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.__interface_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for interface_name, mapped from YANG variable /logical_interface_state/main_interface_physical/logical_interface_physical/interface_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_interface_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_interface_name() directly.
YANG Description: interface name | f336496:c0:m22 |
def _get_is_binded(self): | return self.__is_binded<EOL> | Getter method for is_binded, mapped from YANG variable /logical_interface_state/main_interface_physical/logical_interface_physical/is_binded (boolean)
YANG Description: Is the lif binded | f336496:c0:m24 |
def _set_is_binded(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__is_binded = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for is_binded, mapped from YANG variable /logical_interface_state/main_interface_physical/logical_interface_physical/is_binded (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_is_binded is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_is_binded() directly.
YANG Description: Is the lif binded | f336496:c0:m25 |
def _get_outer_vlan_id(self): | return self.__outer_vlan_id<EOL> | Getter method for outer_vlan_id, mapped from YANG variable /logical_interface_state/main_interface_physical/logical_interface_physical/outer_vlan_id (uint32)
YANG Description: outer vlan id | f336496:c0:m27 |
def _set_outer_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.__outer_vlan_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for outer_vlan_id, mapped from YANG variable /logical_interface_state/main_interface_physical/logical_interface_physical/outer_vlan_id (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_outer_vlan_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_outer_vlan_id() directly.
YANG Description: outer vlan id | f336496:c0:m28 |
def _get_inner_vlan_id(self): | return self.__inner_vlan_id<EOL> | Getter method for inner_vlan_id, mapped from YANG variable /logical_interface_state/main_interface_physical/logical_interface_physical/inner_vlan_id (uint32)
YANG Description: inner vlan id | f336496:c0:m30 |
def _set_inner_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.__inner_vlan_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for inner_vlan_id, mapped from YANG variable /logical_interface_state/main_interface_physical/logical_interface_physical/inner_vlan_id (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_inner_vlan_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_inner_vlan_id() directly.
YANG Description: inner vlan id | f336496:c0:m31 |
def _get_intf_type(self): | return self.__intf_type<EOL> | Getter method for intf_type, mapped from YANG variable /logical_interface_state/main_interface_physical/logical_interface_physical/intf_type (intf-type)
YANG Description: interface type | f336496:c0:m33 |
def _set_intf_type(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:3>}},), 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.__intf_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for intf_type, mapped from YANG variable /logical_interface_state/main_interface_physical/logical_interface_physical/intf_type (intf-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_intf_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_intf_type() directly.
YANG Description: interface type | f336496:c0:m34 |
def _get_is_tagged(self): | return self.__is_tagged<EOL> | Getter method for is_tagged, mapped from YANG variable /logical_interface_state/main_interface_physical/logical_interface_physical/is_tagged (boolean)
YANG Description: is Lif tagged | f336496:c0:m36 |
def _set_is_tagged(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__is_tagged = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for is_tagged, mapped from YANG variable /logical_interface_state/main_interface_physical/logical_interface_physical/is_tagged (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_is_tagged is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_is_tagged() directly.
YANG Description: is Lif tagged | f336496:c0:m37 |
def _get_main_interface_pseudo_wire(self): | return self.__main_interface_pseudo_wire<EOL> | Getter method for main_interface_pseudo_wire, mapped from YANG variable /logical_interface_state/main_interface_pseudo_wire (container)
YANG Description: main interface pseudo wire | f336497:c0:m3 |
def _set_main_interface_pseudo_wire(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=main_interface_pseudo_wire.main_interface_pseudo_wire, 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.__main_interface_pseudo_wire = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for main_interface_pseudo_wire, mapped from YANG variable /logical_interface_state/main_interface_pseudo_wire (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_main_interface_pseudo_wire is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_main_interface_pseudo_wire() directly.
YANG Description: main interface pseudo wire | f336497:c0:m4 |
def _get_main_interface_tunnel(self): | return self.__main_interface_tunnel<EOL> | Getter method for main_interface_tunnel, mapped from YANG variable /logical_interface_state/main_interface_tunnel (container)
YANG Description: main interface tunnel | f336497:c0:m6 |
def _set_main_interface_tunnel(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=main_interface_tunnel.main_interface_tunnel, 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.__main_interface_tunnel = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for main_interface_tunnel, mapped from YANG variable /logical_interface_state/main_interface_tunnel (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_main_interface_tunnel is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_main_interface_tunnel() directly.
YANG Description: main interface tunnel | f336497:c0:m7 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.