signature
stringlengths 8
3.44k
| body
stringlengths 0
1.41M
| docstring
stringlengths 1
122k
| id
stringlengths 5
17
|
|---|---|---|---|
def _get_grace_period_memory(self): | return self.__grace_period_memory<EOL> | Getter method for grace_period_memory, mapped from YANG variable /resource_monitor/memory/grace_period_memory (uint32) | f336822:c0:m18 |
def _set_grace_period_memory(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': 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.__grace_period_memory = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for grace_period_memory, mapped from YANG variable /resource_monitor/memory/grace_period_memory (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_grace_period_memory is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_grace_period_memory() directly. | f336822:c0:m19 |
def _get_offset_memory(self): | return self.__offset_memory<EOL> | Getter method for offset_memory, mapped from YANG variable /resource_monitor/memory/offset_memory (uint32) | f336822:c0:m21 |
def _set_offset_memory(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': 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.__offset_memory = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for offset_memory, mapped from YANG variable /resource_monitor/memory/offset_memory (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_offset_memory is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_offset_memory() directly. | f336822:c0:m22 |
def _get_adj_state_change_time(self): | return self.__adj_state_change_time<EOL> | Getter method for adj_state_change_time, mapped from YANG variable /adj_neighbor_entries_state/adj_neighbor/adj_state_change_time (uint32)
YANG Description: Adjacency State Change Time in seconds | f336823:c0:m3 |
def _set_adj_state_change_time(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=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.__adj_state_change_time = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for adj_state_change_time, mapped from YANG variable /adj_neighbor_entries_state/adj_neighbor/adj_state_change_time (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_adj_state_change_time is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_adj_state_change_time() directly.
YANG Description: Adjacency State Change Time in seconds | f336823:c0:m4 |
def _get_adj_type(self): | return self.__adj_type<EOL> | Getter method for adj_type, mapped from YANG variable /adj_neighbor_entries_state/adj_neighbor/adj_type (isis-adj-type)
YANG Description: Type of ISIS Adjacency | f336823:c0:m6 |
def _set_adj_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:8>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:4>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:0>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:16>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__adj_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for adj_type, mapped from YANG variable /adj_neighbor_entries_state/adj_neighbor/adj_type (isis-adj-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_adj_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_adj_type() directly.
YANG Description: Type of ISIS Adjacency | f336823:c0:m7 |
def _get_adj_state(self): | return self.__adj_state<EOL> | Getter method for adj_state, mapped from YANG variable /adj_neighbor_entries_state/adj_neighbor/adj_state (string)
YANG Description: Adjacency State | f336823:c0:m9 |
def _set_adj_state(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__adj_state = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for adj_state, mapped from YANG variable /adj_neighbor_entries_state/adj_neighbor/adj_state (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_adj_state is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_adj_state() directly.
YANG Description: Adjacency State | f336823:c0:m10 |
def _get_neighbor_id(self): | return self.__neighbor_id<EOL> | Getter method for neighbor_id, mapped from YANG variable /adj_neighbor_entries_state/adj_neighbor/neighbor_id (string)
YANG Description: Neighbor ID | f336823:c0:m12 |
def _set_neighbor_id(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", 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.__neighbor_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for neighbor_id, mapped from YANG variable /adj_neighbor_entries_state/adj_neighbor/neighbor_id (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_neighbor_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_neighbor_id() directly.
YANG Description: Neighbor ID | f336823:c0:m13 |
def _get_circuit_intf_name(self): | return self.__circuit_intf_name<EOL> | Getter method for circuit_intf_name, mapped from YANG variable /adj_neighbor_entries_state/adj_neighbor/circuit_intf_name (string)
YANG Description: Circut Interface Name | f336823:c0:m15 |
def _set_circuit_intf_name(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=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.__circuit_intf_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for circuit_intf_name, mapped from YANG variable /adj_neighbor_entries_state/adj_neighbor/circuit_intf_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_circuit_intf_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_circuit_intf_name() directly.
YANG Description: Circut Interface Name | f336823:c0:m16 |
def _get_snpa(self): | return self.__snpa<EOL> | Getter method for snpa, mapped from YANG variable /adj_neighbor_entries_state/adj_neighbor/snpa (string)
YANG Description: Subnetwork Point of Attachment | f336823:c0:m18 |
def _set_snpa(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.__snpa = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for snpa, mapped from YANG variable /adj_neighbor_entries_state/adj_neighbor/snpa (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_snpa is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_snpa() directly.
YANG Description: Subnetwork Point of Attachment | f336823:c0:m19 |
def _get_adj_holding_time(self): | return self.__adj_holding_time<EOL> | Getter method for adj_holding_time, mapped from YANG variable /adj_neighbor_entries_state/adj_neighbor/adj_holding_time (uint8)
YANG Description: Adjacency Holding Time | f336823:c0:m21 |
def _set_adj_holding_time(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:8>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__adj_holding_time = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for adj_holding_time, mapped from YANG variable /adj_neighbor_entries_state/adj_neighbor/adj_holding_time (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_adj_holding_time is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_adj_holding_time() directly.
YANG Description: Adjacency Holding Time | f336823:c0:m22 |
def _get_adj_priority(self): | return self.__adj_priority<EOL> | Getter method for adj_priority, mapped from YANG variable /adj_neighbor_entries_state/adj_neighbor/adj_priority (uint8)
YANG Description: Adjacency Priority | f336823:c0:m24 |
def _set_adj_priority(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:8>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__adj_priority = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for adj_priority, mapped from YANG variable /adj_neighbor_entries_state/adj_neighbor/adj_priority (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_adj_priority is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_adj_priority() directly.
YANG Description: Adjacency Priority | f336823:c0:m25 |
def _get_adj_mtprot(self): | return self.__adj_mtprot<EOL> | Getter method for adj_mtprot, mapped from YANG variable /adj_neighbor_entries_state/adj_neighbor/adj_mtprot (isis-adj-prot-type)
YANG Description: Adjacency Multi-topology Protocol Type | f336823:c0:m27 |
def _set_adj_mtprot(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:0>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:8>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:4>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__adj_mtprot = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for adj_mtprot, mapped from YANG variable /adj_neighbor_entries_state/adj_neighbor/adj_mtprot (isis-adj-prot-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_adj_mtprot is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_adj_mtprot() directly.
YANG Description: Adjacency Multi-topology Protocol Type | f336823:c0:m28 |
def _get_adj_prot(self): | return self.__adj_prot<EOL> | Getter method for adj_prot, mapped from YANG variable /adj_neighbor_entries_state/adj_neighbor/adj_prot (isis-adj-prot-type)
YANG Description: Adjacency Protocol Type | f336823:c0:m30 |
def _set_adj_prot(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:0>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:8>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:4>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__adj_prot = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for adj_prot, mapped from YANG variable /adj_neighbor_entries_state/adj_neighbor/adj_prot (isis-adj-prot-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_adj_prot is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_adj_prot() directly.
YANG Description: Adjacency Protocol Type | f336823:c0:m31 |
def _get_remaining_time(self): | return self.__remaining_time<EOL> | Getter method for remaining_time, mapped from YANG variable /adj_neighbor_entries_state/adj_neighbor/remaining_time (uint32)
YANG Description: Neighbor Gracefully Restarting Remaining Time in seconds | f336823:c0:m33 |
def _set_remaining_time(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=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.__remaining_time = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for remaining_time, mapped from YANG variable /adj_neighbor_entries_state/adj_neighbor/remaining_time (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_remaining_time is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_remaining_time() directly.
YANG Description: Neighbor Gracefully Restarting Remaining Time in seconds | f336823:c0:m34 |
def _get_adj_3way_state(self): | return self.__adj_3way_state<EOL> | Getter method for adj_3way_state, mapped from YANG variable /adj_neighbor_entries_state/adj_neighbor/adj_3way_state (isis-dcm-3way-adj-state)
YANG Description: Adjacency 3 Way Hand Shaking State | f336823:c0:m36 |
def _set_adj_3way_state(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={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:2>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:3>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:0>}},), 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.__adj_3way_state = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for adj_3way_state, mapped from YANG variable /adj_neighbor_entries_state/adj_neighbor/adj_3way_state (isis-dcm-3way-adj-state)
If this variable is read-only (config: false) in the
source YANG file, then _set_adj_3way_state is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_adj_3way_state() directly.
YANG Description: Adjacency 3 Way Hand Shaking State | f336823:c0:m37 |
def _get_host_name(self): | return self.__host_name<EOL> | Getter method for host_name, mapped from YANG variable /adj_neighbor_entries_state/adj_neighbor/host_name (string)
YANG Description: Host Name | f336823:c0:m39 |
def _set_host_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.__host_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for host_name, mapped from YANG variable /adj_neighbor_entries_state/adj_neighbor/host_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_host_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_host_name() directly.
YANG Description: Host Name | f336823:c0:m40 |
def _get_adj_lan_name(self): | return self.__adj_lan_name<EOL> | Getter method for adj_lan_name, mapped from YANG variable /adj_neighbor_entries_state/adj_neighbor/adj_lan_name (string)
YANG Description: Lan Name | f336823:c0:m42 |
def _set_adj_lan_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.__adj_lan_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for adj_lan_name, mapped from YANG variable /adj_neighbor_entries_state/adj_neighbor/adj_lan_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_adj_lan_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_adj_lan_name() directly.
YANG Description: Lan Name | f336823:c0:m43 |
def _get_adj_lan_id(self): | return self.__adj_lan_id<EOL> | Getter method for adj_lan_id, mapped from YANG variable /adj_neighbor_entries_state/adj_neighbor/adj_lan_id (uint8)
YANG Description: Adjacency LAN ID | f336823:c0:m45 |
def _set_adj_lan_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=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:8>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__adj_lan_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for adj_lan_id, mapped from YANG variable /adj_neighbor_entries_state/adj_neighbor/adj_lan_id (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_adj_lan_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_adj_lan_id() directly.
YANG Description: Adjacency LAN ID | f336823:c0:m46 |
def _get_adj_p2p_circ_id(self): | return self.__adj_p2p_circ_id<EOL> | Getter method for adj_p2p_circ_id, mapped from YANG variable /adj_neighbor_entries_state/adj_neighbor/adj_p2p_circ_id (uint32)
YANG Description: Adjacency Point-to-Point Circuit ID | f336823:c0:m48 |
def _set_adj_p2p_circ_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.__adj_p2p_circ_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for adj_p2p_circ_id, mapped from YANG variable /adj_neighbor_entries_state/adj_neighbor/adj_p2p_circ_id (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_adj_p2p_circ_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_adj_p2p_circ_id() directly.
YANG Description: Adjacency Point-to-Point Circuit ID | f336823:c0:m49 |
def _get_adj_num_adds(self): | return self.__adj_num_adds<EOL> | Getter method for adj_num_adds, mapped from YANG variable /adj_neighbor_entries_state/adj_neighbor/adj_num_adds (uint8)
YANG Description: Number Of NSAPS/Areas Associated To The Adjacency | f336823:c0:m51 |
def _set_adj_num_adds(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:8>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__adj_num_adds = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for adj_num_adds, mapped from YANG variable /adj_neighbor_entries_state/adj_neighbor/adj_num_adds (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_adj_num_adds is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_adj_num_adds() directly.
YANG Description: Number Of NSAPS/Areas Associated To The Adjacency | f336823:c0:m52 |
def _get_adj_use(self): | return self.__adj_use<EOL> | Getter method for adj_use, mapped from YANG variable /adj_neighbor_entries_state/adj_neighbor/adj_use (isis-spf-level)
YANG Description: Adjacency Level Usage | f336823:c0:m54 |
def _set_adj_use(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:3>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__adj_use = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for adj_use, mapped from YANG variable /adj_neighbor_entries_state/adj_neighbor/adj_use (isis-spf-level)
If this variable is read-only (config: false) in the
source YANG file, then _set_adj_use is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_adj_use() directly.
YANG Description: Adjacency Level Usage | f336823:c0:m55 |
def _get_ip_circuit_id(self): | return self.__ip_circuit_id<EOL> | Getter method for ip_circuit_id, mapped from YANG variable /adj_neighbor_entries_state/adj_neighbor/ip_circuit_id (uint32)
YANG Description: ISIS IP Circuit ID | f336823:c0:m57 |
def _set_ip_circuit_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.__ip_circuit_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ip_circuit_id, mapped from YANG variable /adj_neighbor_entries_state/adj_neighbor/ip_circuit_id (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_ip_circuit_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ip_circuit_id() directly.
YANG Description: ISIS IP Circuit ID | f336823:c0:m58 |
def _get_adj_address(self): | return self.__adj_address<EOL> | Getter method for adj_address, mapped from YANG variable /adj_neighbor_entries_state/adj_neighbor/adj_address (inet:ipv4-address)
YANG Description: IPv4 Circuit Address | f336823:c0:m60 |
def _set_adj_address(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=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.__adj_address = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for adj_address, mapped from YANG variable /adj_neighbor_entries_state/adj_neighbor/adj_address (inet:ipv4-address)
If this variable is read-only (config: false) in the
source YANG file, then _set_adj_address is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_adj_address() directly.
YANG Description: IPv4 Circuit Address | f336823:c0:m61 |
def _get_ip6_circuit_id(self): | return self.__ip6_circuit_id<EOL> | Getter method for ip6_circuit_id, mapped from YANG variable /adj_neighbor_entries_state/adj_neighbor/ip6_circuit_id (uint32)
YANG Description: ISIS IPv6 Circuit ID | f336823:c0:m63 |
def _set_ip6_circuit_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.__ip6_circuit_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ip6_circuit_id, mapped from YANG variable /adj_neighbor_entries_state/adj_neighbor/ip6_circuit_id (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_ip6_circuit_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ip6_circuit_id() directly.
YANG Description: ISIS IPv6 Circuit ID | f336823:c0:m64 |
def _get_adj_ip6_address(self): | return self.__adj_ip6_address<EOL> | Getter method for adj_ip6_address, mapped from YANG variable /adj_neighbor_entries_state/adj_neighbor/adj_ip6_address (string)
YANG Description: IPv6 Circuit Address | f336823:c0:m66 |
def _set_adj_ip6_address(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__adj_ip6_address = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for adj_ip6_address, mapped from YANG variable /adj_neighbor_entries_state/adj_neighbor/adj_ip6_address (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_adj_ip6_address is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_adj_ip6_address() directly.
YANG Description: IPv6 Circuit Address | f336823:c0:m67 |
def _get_bfd_holdover_interval(self): | return self.__bfd_holdover_interval<EOL> | Getter method for bfd_holdover_interval, mapped from YANG variable /adj_neighbor_entries_state/adj_neighbor/bfd_holdover_interval (uint8)
YANG Description: ISIS BFD Holdover Interval | f336823:c0:m69 |
def _set_bfd_holdover_interval(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:8>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__bfd_holdover_interval = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for bfd_holdover_interval, mapped from YANG variable /adj_neighbor_entries_state/adj_neighbor/bfd_holdover_interval (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_bfd_holdover_interval is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_bfd_holdover_interval() directly.
YANG Description: ISIS BFD Holdover Interval | f336823:c0:m70 |
def _get_adj_bfd_holdover_time(self): | return self.__adj_bfd_holdover_time<EOL> | Getter method for adj_bfd_holdover_time, mapped from YANG variable /adj_neighbor_entries_state/adj_neighbor/adj_bfd_holdover_time (uint8)
YANG Description: ISIS Adjacency BFD holdover timer | f336823:c0:m72 |
def _set_adj_bfd_holdover_time(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:8>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__adj_bfd_holdover_time = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for adj_bfd_holdover_time, mapped from YANG variable /adj_neighbor_entries_state/adj_neighbor/adj_bfd_holdover_time (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_adj_bfd_holdover_time is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_adj_bfd_holdover_time() directly.
YANG Description: ISIS Adjacency BFD holdover timer | f336823:c0:m73 |
def _get_bfd_state(self): | return self.__bfd_state<EOL> | Getter method for bfd_state, mapped from YANG variable /adj_neighbor_entries_state/adj_neighbor/bfd_state (string)
YANG Description: ISIS BFD State | f336823:c0:m75 |
def _set_bfd_state(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__bfd_state = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for bfd_state, mapped from YANG variable /adj_neighbor_entries_state/adj_neighbor/bfd_state (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_bfd_state is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_bfd_state() directly.
YANG Description: ISIS BFD State | f336823:c0:m76 |
def _get_adj_area(self): | return self.__adj_area<EOL> | Getter method for adj_area, mapped from YANG variable /adj_neighbor_entries_state/adj_neighbor/adj_area (list)
YANG Description: Area Addresses | f336823:c0:m78 |
def _set_adj_area(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>",adj_area.adj_area, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT>', extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}), is_container='<STR_LIT:list>', yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:list>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__adj_area = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for adj_area, mapped from YANG variable /adj_neighbor_entries_state/adj_neighbor/adj_area (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_adj_area is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_adj_area() directly.
YANG Description: Area Addresses | f336823:c0:m79 |
def _get_service_policy(self): | return self.__service_policy<EOL> | Getter method for service_policy, mapped from YANG variable /system_qos/qos/service_policy (list) | f336824:c0:m3 |
def _set_service_policy(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGListType("<STR_LIT>",service_policy.service_policy, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT>', extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None}}), is_container='<STR_LIT:list>', yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:list>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__service_policy = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for service_policy, mapped from YANG variable /system_qos/qos/service_policy (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_service_policy is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_service_policy() directly. | f336824:c0:m4 |
def _get_download(self): | return self.__download<EOL> | Getter method for download, mapped from YANG variable /firmware/download (container) | f336825:c0:m3 |
def _set_download(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=download.download, 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:action>': 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.__download = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for download, mapped from YANG variable /firmware/download (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_download is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_download() directly. | f336825:c0:m4 |
def _get_queue_id(self): | return self.__queue_id<EOL> | Getter method for queue_id, mapped from YANG variable /cpu_queue_info_state/cpu_queue_info_details/queue_id (uint8)
YANG Description: CPU Queue ID | f336826:c0:m3 |
def _set_queue_id(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:8>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, 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.__queue_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for queue_id, mapped from YANG variable /cpu_queue_info_state/cpu_queue_info_details/queue_id (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_queue_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_queue_id() directly.
YANG Description: CPU Queue ID | f336826:c0:m4 |
def _get_fps(self): | return self.__fps<EOL> | Getter method for fps, mapped from YANG variable /cpu_queue_info_state/cpu_queue_info_details/fps (uint32)
YANG Description: Queue rate in fps | f336826:c0:m6 |
def _set_fps(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.__fps = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for fps, mapped from YANG variable /cpu_queue_info_state/cpu_queue_info_details/fps (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_fps is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_fps() directly.
YANG Description: Queue rate in fps | f336826:c0:m7 |
def _get_priority(self): | return self.__priority<EOL> | Getter method for priority, mapped from YANG variable /cpu_queue_info_state/cpu_queue_info_details/priority (uint8)
YANG Description: CPU queue priority | f336826:c0:m9 |
def _set_priority(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:8>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__priority = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for priority, mapped from YANG variable /cpu_queue_info_state/cpu_queue_info_details/priority (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_priority is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_priority() directly.
YANG Description: CPU queue priority | f336826:c0:m10 |
def _get_usage(self): | return self.__usage<EOL> | Getter method for usage, mapped from YANG variable /cpu_queue_info_state/cpu_queue_info_details/usage (string)
YANG Description: Usage details | f336826:c0:m12 |
def _set_usage(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.__usage = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for usage, mapped from YANG variable /cpu_queue_info_state/cpu_queue_info_details/usage (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_usage is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_usage() directly.
YANG Description: Usage details | f336826:c0:m13 |
def _get_credits(self): | return self.__credits<EOL> | Getter method for credits, mapped from YANG variable /cpu_queue_info_state/credits (uint32)
YANG Description: Unused Credits | f336827:c0:m3 |
def _set_credits(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.__credits = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for credits, mapped from YANG variable /cpu_queue_info_state/credits (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_credits is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_credits() directly.
YANG Description: Unused Credits | f336827:c0:m4 |
def _get_cpu_queue_info_details(self): | return self.__cpu_queue_info_details<EOL> | Getter method for cpu_queue_info_details, mapped from YANG variable /cpu_queue_info_state/cpu_queue_info_details (list)
YANG Description: CPU Queue fps and usage | f336827:c0:m6 |
def _set_cpu_queue_info_details(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>",cpu_queue_info_details.cpu_queue_info_details, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT>', extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}), is_container='<STR_LIT:list>', yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:list>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__cpu_queue_info_details = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for cpu_queue_info_details, mapped from YANG variable /cpu_queue_info_state/cpu_queue_info_details (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_cpu_queue_info_details is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_cpu_queue_info_details() directly.
YANG Description: CPU Queue fps and usage | f336827:c0:m7 |
def _get_extcommunity_list_name(self): | return self.__extcommunity_list_name<EOL> | Getter method for extcommunity_list_name, mapped from YANG variable /ip/hide_ext_community_list_holder/extcommunity_list/standard/extcommunity_list_name (ip-extcommunity-list-name-t) | f336828:c0:m3 |
def _set_extcommunity_list_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, extensions={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.__extcommunity_list_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for extcommunity_list_name, mapped from YANG variable /ip/hide_ext_community_list_holder/extcommunity_list/standard/extcommunity_list_name (ip-extcommunity-list-name-t)
If this variable is read-only (config: false) in the
source YANG file, then _set_extcommunity_list_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_extcommunity_list_name() directly. | f336828:c0:m4 |
def _get_ext_community_action(self): | return self.__ext_community_action<EOL> | Getter method for ext_community_action, mapped from YANG variable /ip/hide_ext_community_list_holder/extcommunity_list/standard/ext_community_action (action-t) | f336828:c0:m6 |
def _set_ext_community_action(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={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.__ext_community_action = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ext_community_action, mapped from YANG variable /ip/hide_ext_community_list_holder/extcommunity_list/standard/ext_community_action (action-t)
If this variable is read-only (config: false) in the
source YANG file, then _set_ext_community_action is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ext_community_action() directly. | f336828:c0:m7 |
def _get_ext_community_expr(self): | return self.__ext_community_expr<EOL> | Getter method for ext_community_expr, mapped from YANG variable /ip/hide_ext_community_list_holder/extcommunity_list/standard/ext_community_expr (extcommunity-list-expr-t) | f336828:c0:m9 |
def _set_ext_community_expr(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>'}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, 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.__ext_community_expr = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ext_community_expr, mapped from YANG variable /ip/hide_ext_community_list_holder/extcommunity_list/standard/ext_community_expr (extcommunity-list-expr-t)
If this variable is read-only (config: false) in the
source YANG file, then _set_ext_community_expr is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ext_community_expr() directly. | f336828:c0:m10 |
def _get_standard(self): | return self.__standard<EOL> | Getter method for standard, mapped from YANG variable /ip/hide_ext_community_list_holder/extcommunity_list/standard (list) | f336829:c0:m3 |
def _set_standard(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>",standard.standard, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT>', extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}), is_container='<STR_LIT:list>', yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:list>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__standard = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for standard, mapped from YANG variable /ip/hide_ext_community_list_holder/extcommunity_list/standard (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_standard is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_standard() directly. | f336829:c0:m4 |
def _get_vc_peer_address(self): | return self.__vc_peer_address<EOL> | Getter method for vc_peer_address, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_peer_address (inet:ipv4-address)
YANG Description: peer address name | f336830:c0:m3 |
def _set_vc_peer_address(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.__vc_peer_address = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vc_peer_address, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_peer_address (inet:ipv4-address)
If this variable is read-only (config: false) in the
source YANG file, then _set_vc_peer_address is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vc_peer_address() directly.
YANG Description: peer address name | f336830:c0:m4 |
def _get_vc_peer_state(self): | return self.__vc_peer_state<EOL> | Getter method for vc_peer_state, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_peer_state (string)
YANG Description: peer state | f336830:c0:m6 |
def _set_vc_peer_state(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__vc_peer_state = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vc_peer_state, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_peer_state (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_vc_peer_state is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vc_peer_state() directly.
YANG Description: peer state | f336830:c0:m7 |
def _get_vc_peer_uptime(self): | return self.__vc_peer_uptime<EOL> | Getter method for vc_peer_uptime, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_peer_uptime (string)
YANG Description: peer uptime | f336830:c0:m9 |
def _set_vc_peer_uptime(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.__vc_peer_uptime = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vc_peer_uptime, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_peer_uptime (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_vc_peer_uptime is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vc_peer_uptime() directly.
YANG Description: peer uptime | f336830:c0:m10 |
def _get_vc_peer_load_balance(self): | return self.__vc_peer_load_balance<EOL> | Getter method for vc_peer_load_balance, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_peer_load_balance (boolean)
YANG Description: peer load balance | f336830:c0:m12 |
def _set_vc_peer_load_balance(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.__vc_peer_load_balance = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vc_peer_load_balance, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_peer_load_balance (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_vc_peer_load_balance is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vc_peer_load_balance() directly.
YANG Description: peer load balance | f336830:c0:m13 |
def _get_vc_peer_cos_enabled(self): | return self.__vc_peer_cos_enabled<EOL> | Getter method for vc_peer_cos_enabled, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_peer_cos_enabled (boolean)
YANG Description: peer cos enabled | f336830:c0:m15 |
def _set_vc_peer_cos_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=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.__vc_peer_cos_enabled = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vc_peer_cos_enabled, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_peer_cos_enabled (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_vc_peer_cos_enabled is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vc_peer_cos_enabled() directly.
YANG Description: peer cos enabled | f336830:c0:m16 |
def _get_vc_peer_cos_value(self): | return self.__vc_peer_cos_value<EOL> | Getter method for vc_peer_cos_value, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_peer_cos_value (uint8)
YANG Description: peer cos value | f336830:c0:m18 |
def _set_vc_peer_cos_value(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:8>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__vc_peer_cos_value = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vc_peer_cos_value, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_peer_cos_value (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_vc_peer_cos_value is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vc_peer_cos_value() directly.
YANG Description: peer cos value | f336830:c0:m19 |
def _get_vc_ldp_tnnl_in_use(self): | return self.__vc_ldp_tnnl_in_use<EOL> | Getter method for vc_ldp_tnnl_in_use, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_ldp_tnnl_in_use (string)
YANG Description: peer tunnel in use | f336830:c0:m21 |
def _set_vc_ldp_tnnl_in_use(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.__vc_ldp_tnnl_in_use = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vc_ldp_tnnl_in_use, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_ldp_tnnl_in_use (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_vc_ldp_tnnl_in_use is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vc_ldp_tnnl_in_use() directly.
YANG Description: peer tunnel in use | f336830:c0:m22 |
def _get_vc_local_label(self): | return self.__vc_local_label<EOL> | Getter method for vc_local_label, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_local_label (uint32)
YANG Description: vc_local_label | f336830:c0:m24 |
def _set_vc_local_label(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.__vc_local_label = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vc_local_label, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_local_label (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_vc_local_label is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vc_local_label() directly.
YANG Description: vc_local_label | f336830:c0:m25 |
def _get_vc_remote_label(self): | return self.__vc_remote_label<EOL> | Getter method for vc_remote_label, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_remote_label (uint32)
YANG Description: vc_remote_label | f336830:c0:m27 |
def _set_vc_remote_label(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.__vc_remote_label = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vc_remote_label, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_remote_label (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_vc_remote_label is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vc_remote_label() directly.
YANG Description: vc_remote_label | f336830:c0:m28 |
def _get_vc_local_mtu(self): | return self.__vc_local_mtu<EOL> | Getter method for vc_local_mtu, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_local_mtu (uint32)
YANG Description: vc_local_mtu | f336830:c0:m30 |
def _set_vc_local_mtu(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.__vc_local_mtu = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vc_local_mtu, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_local_mtu (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_vc_local_mtu is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vc_local_mtu() directly.
YANG Description: vc_local_mtu | f336830:c0:m31 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.