signature stringlengths 8 3.44k | body stringlengths 0 1.41M | docstring stringlengths 1 122k | id stringlengths 5 17 |
|---|---|---|---|
def _get_ifname(self): | return self.__ifname<EOL> | Getter method for ifname, mapped from YANG variable /opstest_state/arpentries/arpe/ifname (string) | f335778:c0:m6 |
def _set_ifname(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.__ifname = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ifname, mapped from YANG variable /opstest_state/arpentries/arpe/ifname (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_ifname is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ifname() directly. | f335778:c0:m7 |
def _get_hwaddr(self): | return self.__hwaddr<EOL> | Getter method for hwaddr, mapped from YANG variable /opstest_state/arpentries/arpe/hwaddr (string) | f335778:c0:m9 |
def _set_hwaddr(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.__hwaddr = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for hwaddr, mapped from YANG variable /opstest_state/arpentries/arpe/hwaddr (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_hwaddr is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_hwaddr() directly. | f335778:c0:m10 |
def _get_permanent(self): | return self.__permanent<EOL> | Getter method for permanent, mapped from YANG variable /opstest_state/arpentries/arpe/permanent (boolean) | f335778:c0:m12 |
def _set_permanent(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.__permanent = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for permanent, mapped from YANG variable /opstest_state/arpentries/arpe/permanent (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_permanent is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_permanent() directly. | f335778:c0:m13 |
def _get_published(self): | return self.__published<EOL> | Getter method for published, mapped from YANG variable /opstest_state/arpentries/arpe/published (boolean) | f335778:c0:m15 |
def _set_published(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.__published = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for published, mapped from YANG variable /opstest_state/arpentries/arpe/published (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_published is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_published() directly. | f335778:c0:m16 |
def _get_layer2id(self): | return self.__layer2id<EOL> | Getter method for layer2id, mapped from YANG variable /opstest_state/routes/route/children/layer2/layer2id (uint32) | f335779:c0:m3 |
def _set_layer2id(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__layer2id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for layer2id, mapped from YANG variable /opstest_state/routes/route/children/layer2/layer2id (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_layer2id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_layer2id() directly. | f335779:c0:m4 |
def _get_parentkeyid(self): | return self.__parentkeyid<EOL> | Getter method for parentkeyid, mapped from YANG variable /opstest_state/routes/route/children/layer2/parentkeyid (uint32) | f335779:c0:m6 |
def _set_parentkeyid(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.__parentkeyid = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for parentkeyid, mapped from YANG variable /opstest_state/routes/route/children/layer2/parentkeyid (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_parentkeyid is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_parentkeyid() directly. | f335779:c0:m7 |
def _get_grandparentKey(self): | return self.__grandparentKey<EOL> | Getter method for grandparentKey, mapped from YANG variable /opstest_state/routes/route/children/layer2/grandparentKey (inet:ipv4-address) | f335779:c0:m9 |
def _set_grandparentKey(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>'}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, 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.__grandparentKey = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for grandparentKey, mapped from YANG variable /opstest_state/routes/route/children/layer2/grandparentKey (inet:ipv4-address)
If this variable is read-only (config: false) in the
source YANG file, then _set_grandparentKey is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_grandparentKey() directly. | f335779:c0:m10 |
def _get_attr3(self): | return self.__attr3<EOL> | Getter method for attr3, mapped from YANG variable /opstest_state/routes/route/children/layer2/attr3 (uint32) | f335779:c0:m12 |
def _set_attr3(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.__attr3 = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for attr3, mapped from YANG variable /opstest_state/routes/route/children/layer2/attr3 (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_attr3 is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_attr3() directly. | f335779:c0:m13 |
def _get_attr4(self): | return self.__attr4<EOL> | Getter method for attr4, mapped from YANG variable /opstest_state/routes/route/children/layer2/attr4 (uint32) | f335779:c0:m15 |
def _set_attr4(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.__attr4 = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for attr4, mapped from YANG variable /opstest_state/routes/route/children/layer2/attr4 (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_attr4 is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_attr4() directly. | f335779:c0:m16 |
def _get_keyid(self): | return self.__keyid<EOL> | Getter method for keyid, mapped from YANG variable /opstest_state/routes/route/children/keyid (uint32) | f335780:c0:m3 |
def _set_keyid(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__keyid = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for keyid, mapped from YANG variable /opstest_state/routes/route/children/keyid (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_keyid is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_keyid() directly. | f335780:c0:m4 |
def _get_parentKey(self): | return self.__parentKey<EOL> | Getter method for parentKey, mapped from YANG variable /opstest_state/routes/route/children/parentKey (inet:ipv4-address) | f335780:c0:m6 |
def _set_parentKey(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>'}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, 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.__parentKey = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for parentKey, mapped from YANG variable /opstest_state/routes/route/children/parentKey (inet:ipv4-address)
If this variable is read-only (config: false) in the
source YANG file, then _set_parentKey is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_parentKey() directly. | f335780:c0:m7 |
def _get_attr1(self): | return self.__attr1<EOL> | Getter method for attr1, mapped from YANG variable /opstest_state/routes/route/children/attr1 (uint32) | f335780:c0:m9 |
def _set_attr1(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.__attr1 = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for attr1, mapped from YANG variable /opstest_state/routes/route/children/attr1 (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_attr1 is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_attr1() directly. | f335780:c0:m10 |
def _get_attr2(self): | return self.__attr2<EOL> | Getter method for attr2, mapped from YANG variable /opstest_state/routes/route/children/attr2 (uint32) | f335780:c0:m12 |
def _set_attr2(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.__attr2 = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for attr2, mapped from YANG variable /opstest_state/routes/route/children/attr2 (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_attr2 is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_attr2() directly. | f335780:c0:m13 |
def _get_layer2(self): | return self.__layer2<EOL> | Getter method for layer2, mapped from YANG variable /opstest_state/routes/route/children/layer2 (list) | f335780:c0:m15 |
def _set_layer2(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>",layer2.layer2, 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>'}}), 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>'}}, 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.__layer2 = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for layer2, mapped from YANG variable /opstest_state/routes/route/children/layer2 (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_layer2 is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_layer2() directly. | f335780:c0:m16 |
def _get_destPrefix(self): | return self.__destPrefix<EOL> | Getter method for destPrefix, mapped from YANG variable /opstest_state/routes/route/destPrefix (inet:ipv4-address) | f335781:c0:m3 |
def _set_destPrefix(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>'}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__destPrefix = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for destPrefix, mapped from YANG variable /opstest_state/routes/route/destPrefix (inet:ipv4-address)
If this variable is read-only (config: false) in the
source YANG file, then _set_destPrefix is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_destPrefix() directly. | f335781:c0:m4 |
def _get_entryMultipathIndex(self): | return self.__entryMultipathIndex<EOL> | Getter method for entryMultipathIndex, mapped from YANG variable /opstest_state/routes/route/entryMultipathIndex (uint32) | f335781:c0:m6 |
def _set_entryMultipathIndex(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.__entryMultipathIndex = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for entryMultipathIndex, mapped from YANG variable /opstest_state/routes/route/entryMultipathIndex (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_entryMultipathIndex is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_entryMultipathIndex() directly. | f335781:c0:m7 |
def _get_prefixLength(self): | return self.__prefixLength<EOL> | Getter method for prefixLength, mapped from YANG variable /opstest_state/routes/route/prefixLength (uint32) | f335781:c0:m9 |
def _set_prefixLength(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.__prefixLength = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for prefixLength, mapped from YANG variable /opstest_state/routes/route/prefixLength (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_prefixLength is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_prefixLength() directly. | f335781:c0:m10 |
def _get_gateway(self): | return self.__gateway<EOL> | Getter method for gateway, mapped from YANG variable /opstest_state/routes/route/gateway (inet:ipv4-address) | f335781:c0:m12 |
def _set_gateway(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>'}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, 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.__gateway = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for gateway, mapped from YANG variable /opstest_state/routes/route/gateway (inet:ipv4-address)
If this variable is read-only (config: false) in the
source YANG file, then _set_gateway is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_gateway() directly. | f335781:c0:m13 |
def _get_outInterfaceName(self): | return self.__outInterfaceName<EOL> | Getter method for outInterfaceName, mapped from YANG variable /opstest_state/routes/route/outInterfaceName (string) | f335781:c0:m15 |
def _set_outInterfaceName(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.__outInterfaceName = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for outInterfaceName, mapped from YANG variable /opstest_state/routes/route/outInterfaceName (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_outInterfaceName is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_outInterfaceName() directly. | f335781:c0:m16 |
def _get_outLabel(self): | return self.__outLabel<EOL> | Getter method for outLabel, mapped from YANG variable /opstest_state/routes/route/outLabel (uint32) | f335781:c0:m18 |
def _set_outLabel(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.__outLabel = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for outLabel, mapped from YANG variable /opstest_state/routes/route/outLabel (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_outLabel is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_outLabel() directly. | f335781:c0:m19 |
def _get_protocol(self): | return self.__protocol<EOL> | Getter method for protocol, mapped from YANG variable /opstest_state/routes/route/protocol (string) | f335781:c0:m21 |
def _set_protocol(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=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.__protocol = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for protocol, mapped from YANG variable /opstest_state/routes/route/protocol (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_protocol is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_protocol() directly. | f335781:c0:m22 |
def _get_vifIndex(self): | return self.__vifIndex<EOL> | Getter method for vifIndex, mapped from YANG variable /opstest_state/routes/route/vifIndex (uint32) | f335781:c0:m24 |
def _set_vifIndex(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.__vifIndex = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vifIndex, mapped from YANG variable /opstest_state/routes/route/vifIndex (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_vifIndex is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vifIndex() directly. | f335781:c0:m25 |
def _get_metric(self): | return self.__metric<EOL> | Getter method for metric, mapped from YANG variable /opstest_state/routes/route/metric (uint32) | f335781:c0:m27 |
def _set_metric(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.__metric = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for metric, mapped from YANG variable /opstest_state/routes/route/metric (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_metric is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_metric() directly. | f335781:c0:m28 |
def _get_useCount(self): | return self.__useCount<EOL> | Getter method for useCount, mapped from YANG variable /opstest_state/routes/route/useCount (uint32) | f335781:c0:m30 |
def _set_useCount(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.__useCount = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for useCount, mapped from YANG variable /opstest_state/routes/route/useCount (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_useCount is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_useCount() directly. | f335781:c0:m31 |
def _get_children(self): | return self.__children<EOL> | Getter method for children, mapped from YANG variable /opstest_state/routes/route/children (list) | f335781:c0:m33 |
def _set_children(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>",children.children, 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>'}}), 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>'}}, 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.__children = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for children, mapped from YANG variable /opstest_state/routes/route/children (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_children is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_children() directly. | f335781:c0:m34 |
def _get_route(self): | return self.__route<EOL> | Getter method for route, mapped from YANG variable /opstest_state/routes/route (list) | f335782:c0:m3 |
def _set_route(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>",route.route, 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=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=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.__route = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for route, mapped from YANG variable /opstest_state/routes/route (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_route is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_route() directly. | f335782:c0:m4 |
def _get_arpentries(self): | return self.__arpentries<EOL> | Getter method for arpentries, mapped from YANG variable /opstest_state/arpentries (container) | f335783:c0:m3 |
def _set_arpentries(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=arpentries.arpentries, 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>'}}, 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.__arpentries = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for arpentries, mapped from YANG variable /opstest_state/arpentries (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_arpentries is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_arpentries() directly. | f335783:c0:m4 |
def _get_summary(self): | return self.__summary<EOL> | Getter method for summary, mapped from YANG variable /opstest_state/summary (container) | f335783:c0:m6 |
def _set_summary(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=summary.summary, 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>'}}, 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.__summary = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for summary, mapped from YANG variable /opstest_state/summary (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_summary is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_summary() directly. | f335783:c0:m7 |
def _get_routes(self): | return self.__routes<EOL> | Getter method for routes, mapped from YANG variable /opstest_state/routes (container) | f335783:c0:m9 |
def _set_routes(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=routes.routes, 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>'}}, 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.__routes = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for routes, mapped from YANG variable /opstest_state/routes (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_routes is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_routes() directly. | f335783:c0:m10 |
def _get_paths_configured(self): | return self.__paths_configured<EOL> | Getter method for paths_configured, mapped from YANG variable /opstest_state/summary/paths_configured (uint32) | f335784:c0:m3 |
def _set_paths_configured(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.__paths_configured = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for paths_configured, mapped from YANG variable /opstest_state/summary/paths_configured (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_paths_configured is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_paths_configured() directly. | f335784:c0:m4 |
def _get_lsps_configured(self): | return self.__lsps_configured<EOL> | Getter method for lsps_configured, mapped from YANG variable /opstest_state/summary/lsps_configured (uint32) | f335784:c0:m6 |
def _set_lsps_configured(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.__lsps_configured = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for lsps_configured, mapped from YANG variable /opstest_state/summary/lsps_configured (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_lsps_configured is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lsps_configured() directly. | f335784:c0:m7 |
def _get_lsps_enabled(self): | return self.__lsps_enabled<EOL> | Getter method for lsps_enabled, mapped from YANG variable /opstest_state/summary/lsps_enabled (uint32) | f335784:c0:m9 |
def _set_lsps_enabled(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.__lsps_enabled = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for lsps_enabled, mapped from YANG variable /opstest_state/summary/lsps_enabled (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_lsps_enabled is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lsps_enabled() directly. | f335784:c0:m10 |
def _get_lsps_operational(self): | return self.__lsps_operational<EOL> | Getter method for lsps_operational, mapped from YANG variable /opstest_state/summary/lsps_operational (uint32) | f335784:c0:m12 |
def _set_lsps_operational(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.__lsps_operational = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for lsps_operational, mapped from YANG variable /opstest_state/summary/lsps_operational (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_lsps_operational is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lsps_operational() directly. | f335784:c0:m13 |
def _get_detour_lsps_up(self): | return self.__detour_lsps_up<EOL> | Getter method for detour_lsps_up, mapped from YANG variable /opstest_state/summary/detour_lsps_up (uint32) | f335784:c0:m15 |
def _set_detour_lsps_up(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=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.__detour_lsps_up = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for detour_lsps_up, mapped from YANG variable /opstest_state/summary/detour_lsps_up (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_detour_lsps_up is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_detour_lsps_up() directly. | f335784:c0:m16 |
def _get_backup_lsps_up(self): | return self.__backup_lsps_up<EOL> | Getter method for backup_lsps_up, mapped from YANG variable /opstest_state/summary/backup_lsps_up (uint32) | f335784:c0:m18 |
def _set_backup_lsps_up(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=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.__backup_lsps_up = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for backup_lsps_up, mapped from YANG variable /opstest_state/summary/backup_lsps_up (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_backup_lsps_up is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_backup_lsps_up() directly. | f335784:c0:m19 |
def _get_bypass_lsps(self): | return self.__bypass_lsps<EOL> | Getter method for bypass_lsps, mapped from YANG variable /opstest_state/summary/bypass_lsps (uint32) | f335784:c0:m21 |
def _set_bypass_lsps(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.__bypass_lsps = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for bypass_lsps, mapped from YANG variable /opstest_state/summary/bypass_lsps (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_bypass_lsps is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_bypass_lsps() directly. | f335784:c0:m22 |
def _get_bypass_lspsUp(self): | return self.__bypass_lspsUp<EOL> | Getter method for bypass_lspsUp, mapped from YANG variable /opstest_state/summary/bypass_lspsUp (uint32) | f335784:c0:m24 |
def _set_bypass_lspsUp(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.__bypass_lspsUp = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for bypass_lspsUp, mapped from YANG variable /opstest_state/summary/bypass_lspsUp (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_bypass_lspsUp is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_bypass_lspsUp() directly. | f335784:c0:m25 |
def _get_bypass_lspsEnabled(self): | return self.__bypass_lspsEnabled<EOL> | Getter method for bypass_lspsEnabled, mapped from YANG variable /opstest_state/summary/bypass_lspsEnabled (uint32) | f335784:c0:m27 |
def _set_bypass_lspsEnabled(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.__bypass_lspsEnabled = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for bypass_lspsEnabled, mapped from YANG variable /opstest_state/summary/bypass_lspsEnabled (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_bypass_lspsEnabled is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_bypass_lspsEnabled() directly. | f335784:c0:m28 |
def _get_ldp_lsps_operational(self): | return self.__ldp_lsps_operational<EOL> | Getter method for ldp_lsps_operational, mapped from YANG variable /opstest_state/summary/ldp_lsps_operational (uint32) | f335784:c0:m30 |
def _set_ldp_lsps_operational(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.__ldp_lsps_operational = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ldp_lsps_operational, mapped from YANG variable /opstest_state/summary/ldp_lsps_operational (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_ldp_lsps_operational is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ldp_lsps_operational() directly. | f335784:c0:m31 |
def _get_transit_lsps_configured(self): | return self.__transit_lsps_configured<EOL> | Getter method for transit_lsps_configured, mapped from YANG variable /opstest_state/summary/transit_lsps_configured (uint32) | f335784:c0:m33 |
def _set_transit_lsps_configured(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.__transit_lsps_configured = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for transit_lsps_configured, mapped from YANG variable /opstest_state/summary/transit_lsps_configured (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_transit_lsps_configured is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_transit_lsps_configured() directly. | f335784:c0:m34 |
def _get_transit_lsps_enabled(self): | return self.__transit_lsps_enabled<EOL> | Getter method for transit_lsps_enabled, mapped from YANG variable /opstest_state/summary/transit_lsps_enabled (uint32) | f335784:c0:m36 |
def _set_transit_lsps_enabled(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.__transit_lsps_enabled = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for transit_lsps_enabled, mapped from YANG variable /opstest_state/summary/transit_lsps_enabled (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_transit_lsps_enabled is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_transit_lsps_enabled() directly. | f335784:c0:m37 |
def _get_transit_lsps_operational(self): | return self.__transit_lsps_operational<EOL> | Getter method for transit_lsps_operational, mapped from YANG variable /opstest_state/summary/transit_lsps_operational (uint32) | f335784:c0:m39 |
def _set_transit_lsps_operational(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.__transit_lsps_operational = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for transit_lsps_operational, mapped from YANG variable /opstest_state/summary/transit_lsps_operational (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_transit_lsps_operational is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_transit_lsps_operational() directly. | f335784:c0:m40 |
def _get_cspf_groups_configured(self): | return self.__cspf_groups_configured<EOL> | Getter method for cspf_groups_configured, mapped from YANG variable /opstest_state/summary/cspf_groups_configured (uint32) | f335784:c0:m42 |
def _set_cspf_groups_configured(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.__cspf_groups_configured = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for cspf_groups_configured, mapped from YANG variable /opstest_state/summary/cspf_groups_configured (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_cspf_groups_configured is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_cspf_groups_configured() directly. | f335784:c0:m43 |
def _get_tunnels_supported(self): | return self.__tunnels_supported<EOL> | Getter method for tunnels_supported, mapped from YANG variable /opstest_state/summary/tunnels_supported (uint32) | f335784:c0:m45 |
def _set_tunnels_supported(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.__tunnels_supported = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for tunnels_supported, mapped from YANG variable /opstest_state/summary/tunnels_supported (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_tunnels_supported is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tunnels_supported() directly. | f335784:c0:m46 |
def _get_tunnels_allocated(self): | return self.__tunnels_allocated<EOL> | Getter method for tunnels_allocated, mapped from YANG variable /opstest_state/summary/tunnels_allocated (uint32) | f335784:c0:m48 |
def _set_tunnels_allocated(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.__tunnels_allocated = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for tunnels_allocated, mapped from YANG variable /opstest_state/summary/tunnels_allocated (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_tunnels_allocated is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tunnels_allocated() directly. | f335784:c0:m49 |
def _get_cross_connects_supported(self): | return self.__cross_connects_supported<EOL> | Getter method for cross_connects_supported, mapped from YANG variable /opstest_state/summary/cross_connects_supported (uint32) | f335784:c0:m51 |
def _set_cross_connects_supported(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.__cross_connects_supported = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for cross_connects_supported, mapped from YANG variable /opstest_state/summary/cross_connects_supported (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_cross_connects_supported is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_cross_connects_supported() directly. | f335784:c0:m52 |
def _get_cross_connects_allocated(self): | return self.__cross_connects_allocated<EOL> | Getter method for cross_connects_allocated, mapped from YANG variable /opstest_state/summary/cross_connects_allocated (uint32) | f335784:c0:m54 |
def _set_cross_connects_allocated(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.__cross_connects_allocated = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for cross_connects_allocated, mapped from YANG variable /opstest_state/summary/cross_connects_allocated (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_cross_connects_allocated is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_cross_connects_allocated() directly. | f335784:c0:m55 |
def _get_autobw_templates_supported(self): | return self.__autobw_templates_supported<EOL> | Getter method for autobw_templates_supported, mapped from YANG variable /opstest_state/summary/autobw_templates_supported (uint32) | f335784:c0:m57 |
def _set_autobw_templates_supported(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.__autobw_templates_supported = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for autobw_templates_supported, mapped from YANG variable /opstest_state/summary/autobw_templates_supported (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_autobw_templates_supported is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_autobw_templates_supported() directly. | f335784:c0:m58 |
def _get_autobw_templates_configured(self): | return self.__autobw_templates_configured<EOL> | Getter method for autobw_templates_configured, mapped from YANG variable /opstest_state/summary/autobw_templates_configured (uint32) | f335784:c0:m60 |
def _set_autobw_templates_configured(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.__autobw_templates_configured = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for autobw_templates_configured, mapped from YANG variable /opstest_state/summary/autobw_templates_configured (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_autobw_templates_configured is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_autobw_templates_configured() directly. | f335784:c0:m61 |
def _get_times_enabled(self): | return self.__times_enabled<EOL> | Getter method for times_enabled, mapped from YANG variable /opstest_state/summary/times_enabled (uint32) | f335784:c0:m63 |
def _set_times_enabled(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.__times_enabled = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for times_enabled, mapped from YANG variable /opstest_state/summary/times_enabled (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_times_enabled is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_times_enabled() directly. | f335784:c0:m64 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.