signature
stringlengths 8
3.44k
| body
stringlengths 0
1.41M
| docstring
stringlengths 1
122k
| id
stringlengths 5
17
|
|---|---|---|---|
def _get_deque_pkt_cnt_aggr(self): | return self.__deque_pkt_cnt_aggr<EOL> | Getter method for deque_pkt_cnt_aggr, mapped from YANG variable /tm_state/tmdevicestataggr/deque_pkt_cnt_aggr (uint64)
YANG Description: deque_pkt_cnt | f337073:c0:m15 |
def _set_deque_pkt_cnt_aggr(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:64>), 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.__deque_pkt_cnt_aggr = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for deque_pkt_cnt_aggr, mapped from YANG variable /tm_state/tmdevicestataggr/deque_pkt_cnt_aggr (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_deque_pkt_cnt_aggr is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_deque_pkt_cnt_aggr() directly.
YANG Description: deque_pkt_cnt | f337073:c0:m16 |
def _get_total_discard_pkt_cnt_aggr(self): | return self.__total_discard_pkt_cnt_aggr<EOL> | Getter method for total_discard_pkt_cnt_aggr, mapped from YANG variable /tm_state/tmdevicestataggr/total_discard_pkt_cnt_aggr (uint64)
YANG Description: total_discard_pkt_cnt | f337073:c0:m18 |
def _set_total_discard_pkt_cnt_aggr(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:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__total_discard_pkt_cnt_aggr = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for total_discard_pkt_cnt_aggr, mapped from YANG variable /tm_state/tmdevicestataggr/total_discard_pkt_cnt_aggr (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_total_discard_pkt_cnt_aggr is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_total_discard_pkt_cnt_aggr() directly.
YANG Description: total_discard_pkt_cnt | f337073:c0:m19 |
def _get_deleted_pkt_cnt_aggr(self): | return self.__deleted_pkt_cnt_aggr<EOL> | Getter method for deleted_pkt_cnt_aggr, mapped from YANG variable /tm_state/tmdevicestataggr/deleted_pkt_cnt_aggr (uint64)
YANG Description: deleted_pkt_cnt | f337073:c0:m21 |
def _set_deleted_pkt_cnt_aggr(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:64>), 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.__deleted_pkt_cnt_aggr = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for deleted_pkt_cnt_aggr, mapped from YANG variable /tm_state/tmdevicestataggr/deleted_pkt_cnt_aggr (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_deleted_pkt_cnt_aggr is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_deleted_pkt_cnt_aggr() directly.
YANG Description: deleted_pkt_cnt | f337073:c0:m22 |
def _get_invalid_queue_pkt_aggr(self): | return self.__invalid_queue_pkt_aggr<EOL> | Getter method for invalid_queue_pkt_aggr, mapped from YANG variable /tm_state/tmdevicestataggr/invalid_queue_pkt_aggr (uint64)
YANG Description: invalid_queue_pkt | f337073:c0:m24 |
def _set_invalid_queue_pkt_aggr(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:64>), 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.__invalid_queue_pkt_aggr = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for invalid_queue_pkt_aggr, mapped from YANG variable /tm_state/tmdevicestataggr/invalid_queue_pkt_aggr (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_invalid_queue_pkt_aggr is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_invalid_queue_pkt_aggr() directly.
YANG Description: invalid_queue_pkt | f337073:c0:m25 |
def _get_cpu_pkt_cnt_aggr(self): | return self.__cpu_pkt_cnt_aggr<EOL> | Getter method for cpu_pkt_cnt_aggr, mapped from YANG variable /tm_state/tmdevicestataggr/cpu_pkt_cnt_aggr (uint64)
YANG Description: cpu_pkt_cnt | f337073:c0:m27 |
def _set_cpu_pkt_cnt_aggr(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:64>), 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.__cpu_pkt_cnt_aggr = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for cpu_pkt_cnt_aggr, mapped from YANG variable /tm_state/tmdevicestataggr/cpu_pkt_cnt_aggr (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_cpu_pkt_cnt_aggr is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_cpu_pkt_cnt_aggr() directly.
YANG Description: cpu_pkt_cnt | f337073:c0:m28 |
def _get_uni_pkt_cnt_aggr(self): | return self.__uni_pkt_cnt_aggr<EOL> | Getter method for uni_pkt_cnt_aggr, mapped from YANG variable /tm_state/tmdevicestataggr/uni_pkt_cnt_aggr (uint64)
YANG Description: uni_pkt_cnt | f337073:c0:m30 |
def _set_uni_pkt_cnt_aggr(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:64>), 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.__uni_pkt_cnt_aggr = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for uni_pkt_cnt_aggr, mapped from YANG variable /tm_state/tmdevicestataggr/uni_pkt_cnt_aggr (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_uni_pkt_cnt_aggr is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_uni_pkt_cnt_aggr() directly.
YANG Description: uni_pkt_cnt | f337073:c0:m31 |
def _get_mcast_pkt_cnt_aggr(self): | return self.__mcast_pkt_cnt_aggr<EOL> | Getter method for mcast_pkt_cnt_aggr, mapped from YANG variable /tm_state/tmdevicestataggr/mcast_pkt_cnt_aggr (uint64)
YANG Description: mcast_pkt_cnt | f337073:c0:m33 |
def _set_mcast_pkt_cnt_aggr(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:64>), 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.__mcast_pkt_cnt_aggr = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mcast_pkt_cnt_aggr, mapped from YANG variable /tm_state/tmdevicestataggr/mcast_pkt_cnt_aggr (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_mcast_pkt_cnt_aggr is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mcast_pkt_cnt_aggr() directly.
YANG Description: mcast_pkt_cnt | f337073:c0:m34 |
def _get_uni_discard_pkt_cnt_aggr(self): | return self.__uni_discard_pkt_cnt_aggr<EOL> | Getter method for uni_discard_pkt_cnt_aggr, mapped from YANG variable /tm_state/tmdevicestataggr/uni_discard_pkt_cnt_aggr (uint64)
YANG Description: uni_discard_pkt_cnt | f337073:c0:m36 |
def _set_uni_discard_pkt_cnt_aggr(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:64>), 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.__uni_discard_pkt_cnt_aggr = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for uni_discard_pkt_cnt_aggr, mapped from YANG variable /tm_state/tmdevicestataggr/uni_discard_pkt_cnt_aggr (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_uni_discard_pkt_cnt_aggr is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_uni_discard_pkt_cnt_aggr() directly.
YANG Description: uni_discard_pkt_cnt | f337073:c0:m37 |
def _get_mcast_discard_pkt_cnt_aggr(self): | return self.__mcast_discard_pkt_cnt_aggr<EOL> | Getter method for mcast_discard_pkt_cnt_aggr, mapped from YANG variable /tm_state/tmdevicestataggr/mcast_discard_pkt_cnt_aggr (uint64)
YANG Description: mcast_discard_pkt_cnt | f337073:c0:m39 |
def _set_mcast_discard_pkt_cnt_aggr(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:64>), 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.__mcast_discard_pkt_cnt_aggr = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mcast_discard_pkt_cnt_aggr, mapped from YANG variable /tm_state/tmdevicestataggr/mcast_discard_pkt_cnt_aggr (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_mcast_discard_pkt_cnt_aggr is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mcast_discard_pkt_cnt_aggr() directly.
YANG Description: mcast_discard_pkt_cnt | f337073:c0:m40 |
def _get_fqp_pkt_cnt_aggr(self): | return self.__fqp_pkt_cnt_aggr<EOL> | Getter method for fqp_pkt_cnt_aggr, mapped from YANG variable /tm_state/tmdevicestataggr/fqp_pkt_cnt_aggr (uint64)
YANG Description: fqp_pkt_cnt | f337073:c0:m42 |
def _set_fqp_pkt_cnt_aggr(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:64>), 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.__fqp_pkt_cnt_aggr = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for fqp_pkt_cnt_aggr, mapped from YANG variable /tm_state/tmdevicestataggr/fqp_pkt_cnt_aggr (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_fqp_pkt_cnt_aggr is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_fqp_pkt_cnt_aggr() directly.
YANG Description: fqp_pkt_cnt | f337073:c0:m43 |
def _get_ehp_discard_cnt_aggr(self): | return self.__ehp_discard_cnt_aggr<EOL> | Getter method for ehp_discard_cnt_aggr, mapped from YANG variable /tm_state/tmdevicestataggr/ehp_discard_cnt_aggr (uint64)
YANG Description: ehp_discard_cnt | f337073:c0:m45 |
def _set_ehp_discard_cnt_aggr(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:64>), 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.__ehp_discard_cnt_aggr = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ehp_discard_cnt_aggr, mapped from YANG variable /tm_state/tmdevicestataggr/ehp_discard_cnt_aggr (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_ehp_discard_cnt_aggr is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ehp_discard_cnt_aggr() directly.
YANG Description: ehp_discard_cnt | f337073:c0:m46 |
def _get_slot_port(self): | return self.__slot_port<EOL> | Getter method for slot_port, mapped from YANG variable /tm_state/non_empty_voq/slot_port (string)
YANG Description: slot/port (first port on device) where queue is non empty | f337074:c0:m3 |
def _set_slot_port(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__slot_port = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for slot_port, mapped from YANG variable /tm_state/non_empty_voq/slot_port (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_slot_port is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_slot_port() directly.
YANG Description: slot/port (first port on device) where queue is non empty | f337074:c0:m4 |
def _get_voq_id(self): | return self.__voq_id<EOL> | Getter method for voq_id, mapped from YANG variable /tm_state/non_empty_voq/voq_id (uint32)
YANG Description: voq id | f337074:c0:m6 |
def _set_voq_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.__voq_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for voq_id, mapped from YANG variable /tm_state/non_empty_voq/voq_id (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_voq_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_voq_id() directly.
YANG Description: voq id | f337074:c0:m7 |
def _get_voq_size(self): | return self.__voq_size<EOL> | Getter method for voq_size, mapped from YANG variable /tm_state/non_empty_voq/voq_size (uint32)
YANG Description: queue size | f337074:c0:m9 |
def _set_voq_size(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__voq_size = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for voq_size, mapped from YANG variable /tm_state/non_empty_voq/voq_size (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_voq_size is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_voq_size() directly.
YANG Description: queue size | f337074:c0:m10 |
def _get_slot_id(self): | return self.__slot_id<EOL> | Getter method for slot_id, mapped from YANG variable /tm_state/tmcpustatsslotallgrp/slot_id (uint16)
YANG Description: slot_id | f337075:c0:m3 |
def _set_slot_id(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']},int_size=<NUM_LIT:16>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__slot_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for slot_id, mapped from YANG variable /tm_state/tmcpustatsslotallgrp/slot_id (uint16)
If this variable is read-only (config: false) in the
source YANG file, then _set_slot_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_slot_id() directly.
YANG Description: slot_id | f337075:c0:m4 |
def _get_enquepkt(self): | return self.__enquepkt<EOL> | Getter method for enquepkt, mapped from YANG variable /tm_state/tmcpustatsslotallgrp/enquepkt (uint64)
YANG Description: enque_pkts | f337075:c0:m6 |
def _set_enquepkt(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:64>), 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.__enquepkt = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for enquepkt, mapped from YANG variable /tm_state/tmcpustatsslotallgrp/enquepkt (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_enquepkt is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_enquepkt() directly.
YANG Description: enque_pkts | f337075:c0:m7 |
def _get_enqueubytes(self): | return self.__enqueubytes<EOL> | Getter method for enqueubytes, mapped from YANG variable /tm_state/tmcpustatsslotallgrp/enqueubytes (uint64)
YANG Description: enque_bytes | f337075:c0:m9 |
def _set_enqueubytes(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:64>), 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.__enqueubytes = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for enqueubytes, mapped from YANG variable /tm_state/tmcpustatsslotallgrp/enqueubytes (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_enqueubytes is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_enqueubytes() directly.
YANG Description: enque_bytes | f337075:c0:m10 |
def _get_discardpkt(self): | return self.__discardpkt<EOL> | Getter method for discardpkt, mapped from YANG variable /tm_state/tmcpustatsslotallgrp/discardpkt (uint64)
YANG Description: discard_pkts | f337075:c0:m12 |
def _set_discardpkt(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:64>), 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.__discardpkt = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for discardpkt, mapped from YANG variable /tm_state/tmcpustatsslotallgrp/discardpkt (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_discardpkt is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_discardpkt() directly.
YANG Description: discard_pkts | f337075:c0:m13 |
def _get_discardbytes(self): | return self.__discardbytes<EOL> | Getter method for discardbytes, mapped from YANG variable /tm_state/tmcpustatsslotallgrp/discardbytes (uint64)
YANG Description: discard_bytes | f337075:c0:m15 |
def _set_discardbytes(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:64>), 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.__discardbytes = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for discardbytes, mapped from YANG variable /tm_state/tmcpustatsslotallgrp/discardbytes (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_discardbytes is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_discardbytes() directly.
YANG Description: discard_bytes | f337075:c0:m16 |
def _get_currdepth(self): | return self.__currdepth<EOL> | Getter method for currdepth, mapped from YANG variable /tm_state/tmcpustatsslotallgrp/currdepth (uint64)
YANG Description: current_queue_depth | f337075:c0:m18 |
def _set_currdepth(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:64>), 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.__currdepth = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for currdepth, mapped from YANG variable /tm_state/tmcpustatsslotallgrp/currdepth (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_currdepth is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_currdepth() directly.
YANG Description: current_queue_depth | f337075:c0:m19 |
def _get_maxdepth(self): | return self.__maxdepth<EOL> | Getter method for maxdepth, mapped from YANG variable /tm_state/tmcpustatsslotallgrp/maxdepth (uint64)
YANG Description: max_queue_depth | f337075:c0:m21 |
def _set_maxdepth(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:64>), 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.__maxdepth = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for maxdepth, mapped from YANG variable /tm_state/tmcpustatsslotallgrp/maxdepth (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_maxdepth is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_maxdepth() directly.
YANG Description: max_queue_depth | f337075:c0:m22 |
def _get_slot_id(self): | return self.__slot_id<EOL> | Getter method for slot_id, mapped from YANG variable /tm_state/tmcpustatsslot/slot_id (uint16)
YANG Description: slot_id | f337076:c0:m3 |
def _set_slot_id(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']},int_size=<NUM_LIT:16>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__slot_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for slot_id, mapped from YANG variable /tm_state/tmcpustatsslot/slot_id (uint16)
If this variable is read-only (config: false) in the
source YANG file, then _set_slot_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_slot_id() directly.
YANG Description: slot_id | f337076:c0:m4 |
def _get_cpugroup_id(self): | return self.__cpugroup_id<EOL> | Getter method for cpugroup_id, mapped from YANG variable /tm_state/tmcpustatsslot/cpugroup_id (uint16)
YANG Description: cpugroup_id | f337076:c0:m6 |
def _set_cpugroup_id(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']},int_size=<NUM_LIT:16>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__cpugroup_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for cpugroup_id, mapped from YANG variable /tm_state/tmcpustatsslot/cpugroup_id (uint16)
If this variable is read-only (config: false) in the
source YANG file, then _set_cpugroup_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_cpugroup_id() directly.
YANG Description: cpugroup_id | f337076:c0:m7 |
def _get_enquepkt(self): | return self.__enquepkt<EOL> | Getter method for enquepkt, mapped from YANG variable /tm_state/tmcpustatsslot/enquepkt (uint64)
YANG Description: enque_pkts | f337076:c0:m9 |
def _set_enquepkt(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:64>), 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.__enquepkt = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for enquepkt, mapped from YANG variable /tm_state/tmcpustatsslot/enquepkt (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_enquepkt is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_enquepkt() directly.
YANG Description: enque_pkts | f337076:c0:m10 |
def _get_enqueubytes(self): | return self.__enqueubytes<EOL> | Getter method for enqueubytes, mapped from YANG variable /tm_state/tmcpustatsslot/enqueubytes (uint64)
YANG Description: enque_bytes | f337076:c0:m12 |
def _set_enqueubytes(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:64>), 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.__enqueubytes = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for enqueubytes, mapped from YANG variable /tm_state/tmcpustatsslot/enqueubytes (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_enqueubytes is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_enqueubytes() directly.
YANG Description: enque_bytes | f337076:c0:m13 |
def _get_discardpkt(self): | return self.__discardpkt<EOL> | Getter method for discardpkt, mapped from YANG variable /tm_state/tmcpustatsslot/discardpkt (uint64)
YANG Description: discard_pkts | f337076:c0:m15 |
def _set_discardpkt(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:64>), 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.__discardpkt = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for discardpkt, mapped from YANG variable /tm_state/tmcpustatsslot/discardpkt (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_discardpkt is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_discardpkt() directly.
YANG Description: discard_pkts | f337076:c0:m16 |
def _get_discardbytes(self): | return self.__discardbytes<EOL> | Getter method for discardbytes, mapped from YANG variable /tm_state/tmcpustatsslot/discardbytes (uint64)
YANG Description: discard_bytes | f337076:c0:m18 |
def _set_discardbytes(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:64>), 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.__discardbytes = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for discardbytes, mapped from YANG variable /tm_state/tmcpustatsslot/discardbytes (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_discardbytes is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_discardbytes() directly.
YANG Description: discard_bytes | f337076:c0:m19 |
def _get_currdepth(self): | return self.__currdepth<EOL> | Getter method for currdepth, mapped from YANG variable /tm_state/tmcpustatsslot/currdepth (uint64)
YANG Description: current_queue_depth | f337076:c0:m21 |
def _set_currdepth(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:64>), 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.__currdepth = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for currdepth, mapped from YANG variable /tm_state/tmcpustatsslot/currdepth (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_currdepth is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_currdepth() directly.
YANG Description: current_queue_depth | f337076:c0:m22 |
def _get_maxdepth(self): | return self.__maxdepth<EOL> | Getter method for maxdepth, mapped from YANG variable /tm_state/tmcpustatsslot/maxdepth (uint64)
YANG Description: max_queue_depth | f337076:c0:m24 |
def _set_maxdepth(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:64>), 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.__maxdepth = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for maxdepth, mapped from YANG variable /tm_state/tmcpustatsslot/maxdepth (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_maxdepth is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_maxdepth() directly.
YANG Description: max_queue_depth | f337076:c0:m25 |
def _get_tmdevicestataggr(self): | return self.__tmdevicestataggr<EOL> | Getter method for tmdevicestataggr, mapped from YANG variable /tm_state/tmdevicestataggr (list)
YANG Description: Get TM device stats from all towers and all slots | f337077:c0:m3 |
def _set_tmdevicestataggr(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>",tmdevicestataggr.tmdevicestataggr, 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.__tmdevicestataggr = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for tmdevicestataggr, mapped from YANG variable /tm_state/tmdevicestataggr (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_tmdevicestataggr is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tmdevicestataggr() directly.
YANG Description: Get TM device stats from all towers and all slots | f337077:c0:m4 |
def _get_non_empty_voq(self): | return self.__non_empty_voq<EOL> | Getter method for non_empty_voq, mapped from YANG variable /tm_state/non_empty_voq (list)
YANG Description: non empty voq's in the system | f337077:c0:m6 |
def _set_non_empty_voq(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>",non_empty_voq.non_empty_voq, 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.__non_empty_voq = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for non_empty_voq, mapped from YANG variable /tm_state/non_empty_voq (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_non_empty_voq is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_non_empty_voq() directly.
YANG Description: non empty voq's in the system | f337077:c0:m7 |
def _get_tmcpustatsslot(self): | return self.__tmcpustatsslot<EOL> | Getter method for tmcpustatsslot, mapped from YANG variable /tm_state/tmcpustatsslot (list)
YANG Description: TM voq stats for CPU port per slot | f337077:c0:m9 |
def _set_tmcpustatsslot(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>",tmcpustatsslot.tmcpustatsslot, 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.__tmcpustatsslot = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for tmcpustatsslot, mapped from YANG variable /tm_state/tmcpustatsslot (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_tmcpustatsslot is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tmcpustatsslot() directly.
YANG Description: TM voq stats for CPU port per slot | f337077:c0:m10 |
def _get_tmcpustatsslotallgrp(self): | return self.__tmcpustatsslotallgrp<EOL> | Getter method for tmcpustatsslotallgrp, mapped from YANG variable /tm_state/tmcpustatsslotallgrp (list)
YANG Description: TM voq stats for CPU port per slot for all CPU group | f337077:c0:m12 |
def _set_tmcpustatsslotallgrp(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>",tmcpustatsslotallgrp.tmcpustatsslotallgrp, 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.__tmcpustatsslotallgrp = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for tmcpustatsslotallgrp, mapped from YANG variable /tm_state/tmcpustatsslotallgrp (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_tmcpustatsslotallgrp is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tmcpustatsslotallgrp() directly.
YANG Description: TM voq stats for CPU port per slot for all CPU group | f337077:c0:m13 |
def _get_tm_top_discard_pkt_data(self): | return self.__tm_top_discard_pkt_data<EOL> | Getter method for tm_top_discard_pkt_data, mapped from YANG variable /tm_state/tm_top_discard_pkt_data (list)
YANG Description: TM voq stats to get list of top discarded destination ports | f337077:c0:m15 |
def _set_tm_top_discard_pkt_data(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>",tm_top_discard_pkt_data.tm_top_discard_pkt_data, 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.__tm_top_discard_pkt_data = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for tm_top_discard_pkt_data, mapped from YANG variable /tm_state/tm_top_discard_pkt_data (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_tm_top_discard_pkt_data is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tm_top_discard_pkt_data() directly.
YANG Description: TM voq stats to get list of top discarded destination ports | f337077:c0:m16 |
def _get_tm_top_max_queue_depth_data(self): | return self.__tm_top_max_queue_depth_data<EOL> | Getter method for tm_top_max_queue_depth_data, mapped from YANG variable /tm_state/tm_top_max_queue_depth_data (list)
YANG Description: TM voq stats to get list of top max queue depth | f337077:c0:m18 |
def _set_tm_top_max_queue_depth_data(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>",tm_top_max_queue_depth_data.tm_top_max_queue_depth_data, 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.__tm_top_max_queue_depth_data = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for tm_top_max_queue_depth_data, mapped from YANG variable /tm_state/tm_top_max_queue_depth_data (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_tm_top_max_queue_depth_data is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tm_top_max_queue_depth_data() directly.
YANG Description: TM voq stats to get list of top max queue depth | f337077:c0:m19 |
def _get_tm_max_buff_util_data(self): | return self.__tm_max_buff_util_data<EOL> | Getter method for tm_max_buff_util_data, mapped from YANG variable /tm_state/tm_max_buff_util_data (list)
YANG Description: Snapshot of max TM buffer utilzation | f337077:c0:m21 |
def _set_tm_max_buff_util_data(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>",tm_max_buff_util_data.tm_max_buff_util_data, 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.__tm_max_buff_util_data = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for tm_max_buff_util_data, mapped from YANG variable /tm_state/tm_max_buff_util_data (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_tm_max_buff_util_data is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tm_max_buff_util_data() directly.
YANG Description: Snapshot of max TM buffer utilzation | f337077:c0:m22 |
def _get_tmvoqstatistics(self): | return self.__tmvoqstatistics<EOL> | Getter method for tmvoqstatistics, mapped from YANG variable /tm_state/tmvoqstatistics (list)
YANG Description: Get TM VOQ statistics | f337077:c0:m24 |
def _set_tmvoqstatistics(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>",tmvoqstatistics.tmvoqstatistics, 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.__tmvoqstatistics = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for tmvoqstatistics, mapped from YANG variable /tm_state/tmvoqstatistics (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_tmvoqstatistics is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tmvoqstatistics() directly.
YANG Description: Get TM VOQ statistics | f337077:c0:m25 |
def _get_load_balance_type(self): | return self.__load_balance_type<EOL> | Getter method for load_balance_type, mapped from YANG variable /load_balance/po_load_balance/load_balance_type (enumeration) | f337078:c0:m3 |
def _set_load_balance_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:6>}, 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:5>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:3>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:7>}},), default=unicode("<STR_LIT>"), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT:info>': 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.__load_balance_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for load_balance_type, mapped from YANG variable /load_balance/po_load_balance/load_balance_type (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_load_balance_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_load_balance_type() directly. | f337078:c0:m4 |
def _get_sa_mac(self): | return self.__sa_mac<EOL> | Getter method for sa_mac, mapped from YANG variable /load_balance/hash/ethernet/sa_mac (empty) | f337079:c0:m3 |
def _set_sa_mac(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=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, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__sa_mac = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for sa_mac, mapped from YANG variable /load_balance/hash/ethernet/sa_mac (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_sa_mac is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_sa_mac() directly. | f337079:c0:m4 |
def _get_da_mac(self): | return self.__da_mac<EOL> | Getter method for da_mac, mapped from YANG variable /load_balance/hash/ethernet/da_mac (empty) | f337079:c0:m6 |
def _set_da_mac(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=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, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__da_mac = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for da_mac, mapped from YANG variable /load_balance/hash/ethernet/da_mac (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_da_mac is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_da_mac() directly. | f337079:c0:m7 |
def _get_vlan(self): | return self.__vlan<EOL> | Getter method for vlan, mapped from YANG variable /load_balance/hash/ethernet/vlan (empty) | f337079:c0:m9 |
def _set_vlan(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, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__vlan = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vlan, mapped from YANG variable /load_balance/hash/ethernet/vlan (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_vlan is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vlan() directly. | f337079:c0:m10 |
def _get_etype(self): | return self.__etype<EOL> | Getter method for etype, mapped from YANG variable /load_balance/hash/ethernet/etype (empty) | f337079:c0:m12 |
def _set_etype(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, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__etype = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for etype, mapped from YANG variable /load_balance/hash/ethernet/etype (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_etype is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_etype() directly. | f337079:c0:m13 |
def _get_label1(self): | return self.__label1<EOL> | Getter method for label1, mapped from YANG variable /load_balance/hash/mpls/label1 (empty) | f337080:c0:m3 |
def _set_label1(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, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__label1 = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for label1, mapped from YANG variable /load_balance/hash/mpls/label1 (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_label1 is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_label1() directly. | f337080:c0:m4 |
def _get_label2(self): | return self.__label2<EOL> | Getter method for label2, mapped from YANG variable /load_balance/hash/mpls/label2 (empty) | f337080:c0:m6 |
def _set_label2(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, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__label2 = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for label2, mapped from YANG variable /load_balance/hash/mpls/label2 (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_label2 is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_label2() directly. | f337080:c0:m7 |
def _get_label3(self): | return self.__label3<EOL> | Getter method for label3, mapped from YANG variable /load_balance/hash/mpls/label3 (empty) | f337080:c0:m9 |
def _set_label3(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, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__label3 = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for label3, mapped from YANG variable /load_balance/hash/mpls/label3 (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_label3 is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_label3() directly. | f337080:c0:m10 |
def _get_src_l4_port(self): | return self.__src_l4_port<EOL> | Getter method for src_l4_port, mapped from YANG variable /load_balance/hash/ip/src_l4_port (empty) | f337081:c0:m3 |
def _set_src_l4_port(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=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, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__src_l4_port = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for src_l4_port, mapped from YANG variable /load_balance/hash/ip/src_l4_port (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_src_l4_port is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_src_l4_port() directly. | f337081:c0:m4 |
def _get_dst_l4_port(self): | return self.__dst_l4_port<EOL> | Getter method for dst_l4_port, mapped from YANG variable /load_balance/hash/ip/dst_l4_port (empty) | f337081:c0:m6 |
def _set_dst_l4_port(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=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, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__dst_l4_port = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for dst_l4_port, mapped from YANG variable /load_balance/hash/ip/dst_l4_port (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_dst_l4_port is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_dst_l4_port() directly. | f337081:c0:m7 |
def _get_src_ip(self): | return self.__src_ip<EOL> | Getter method for src_ip, mapped from YANG variable /load_balance/hash/ip/src_ip (empty) | f337081:c0:m9 |
def _set_src_ip(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, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__src_ip = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for src_ip, mapped from YANG variable /load_balance/hash/ip/src_ip (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_src_ip is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_src_ip() directly. | f337081:c0:m10 |
def _get_dst_ip(self): | return self.__dst_ip<EOL> | Getter method for dst_ip, mapped from YANG variable /load_balance/hash/ip/dst_ip (empty) | f337081:c0:m12 |
def _set_dst_ip(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, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__dst_ip = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for dst_ip, mapped from YANG variable /load_balance/hash/ip/dst_ip (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_dst_ip is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_dst_ip() directly. | f337081:c0:m13 |
def _get_protocol(self): | return self.__protocol<EOL> | Getter method for protocol, mapped from YANG variable /load_balance/hash/ip/protocol (empty) | f337081:c0:m15 |
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=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, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__protocol = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for protocol, mapped from YANG variable /load_balance/hash/ip/protocol (empty)
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. | f337081:c0:m16 |
Subsets and Splits