Return LabelValue with FSM derived keys.
350156
def LabelValueTable(self, keys=None):
        """"""
        keys = keys or self.superkey
        # pylint: disable=E1002
        return super(CliTable, self).LabelValueTable(keys)
703962
def valuestodict(key):
    """"""
    dict = {}
    size = winreg.QueryInfoKey(key)[1]
    for i in range(size):
        data = winreg.EnumValue(key, i)
        dict[data[0]] = data[1]
    return dict
384230
def reverse_lookup(self, value, condition=is_active):
        '''  '''
        label = get_value_label(value, self._picklist, condition=condition)
        return label
739120
def label_const(self, const:Any=0, label_cls:Callable=None, **kwargs)->'LabelList':
        ""
        return self.label_from_func(func=lambda o: const, label_cls=label_cls, **kwargs)
1080837
def cget(self, key):
        
        if key == 'showvalue':
            return self._showvalue
        elif key == 'tickinterval':
            return self._tickinterval
        elif key == 'tickpos':
            return self._tickpos
        elif key == 'labelpos':
            return self._labelpos
        elif key == 'digits':
            return self._digits
        elif key == 'resolution':
            return self._resolution
        else:
            return self.scale.cget(key)
737109
def get_comparable_values(self):
        
        return (int(self.major), int(self.minor), str(self.label), str(self.name))
296037
def ccmodmsk_class_label_lookup(label):
    """"""

    clsmod = {'ism': admm_ccmod.ConvCnstrMODMaskDcpl_IterSM,
              'cg': admm_ccmod.ConvCnstrMODMaskDcpl_CG,
              'cns': admm_ccmod.ConvCnstrMODMaskDcpl_Consensus,
              'fista': fista_ccmod.ConvCnstrMODMask}
    if label in clsmod:
        return clsmod[label]
    else:
        raise ValueError('Unknown ConvCnstrMODMask solver method %s' % label)
1203623
function labels (configName, callback) {

    if (callback) {
        return get(configName).schema.statics.getLabels(callback);
    }

    return get(configName).schema.statics.getLabels();
}
674462
def get_name2value_dict(self):
        """"""
        x = {}
        for val, num in self._values:
            x[val] = num
        return x
310803
def _keys_from_label(self, label):
        '''
        '''
        k1 = (label.content_id1, label.content_id2,
              label.annotator_id, time_complement(label.epoch_ticks))
        k2 = (label.content_id2, label.content_id1,
              label.annotator_id, time_complement(label.epoch_ticks))
        return k1, k2
684555
def raw_value(self) -> RawValue:
        """"""
        if isinstance(self.value, ObjectValue):
            return {m: self._member(m).raw_value() for m in self.value}
        if isinstance(self.value, ArrayValue):
            return [en.raw_value() for en in self]
        return self.schema_node.type.to_raw(self.value)
1161906
def get_label_names(ctx):
    """"""
    labels = [
        label
        for label in ctx.__dict__
        if not label.startswith("_")
        and label
        not in [
            "children",
            "exception",
            "invokingState",
            "parentCtx",
            "parser",
            "start",
            "stop",
        ]
    ]
    return labels
1231098
def imm_values(imm):
    '''
    
    '''
    return {p: getattr(imm, p) for p in six.iterkeys(_imm_value_data(imm))}
23957
def label(self):
        ""
        if self._label:
            return self._label
        else:
            if len(self):
                label = get_ndmapping_label(self, 'label')
                return '' if label is None else label
            else:
                return ''
963731
def parse_value(self, sn: "DataNode") -> ScalarValue:
        """"""
        res = sn.type.parse_value(self.value)
        if res is None:
            raise InvalidKeyValue(self.value)
        return res
1224174
def get_field_entry_key(node):
    # type: (Field) -> str
    """"""
    if node.alias:
        return node.alias.value
    return node.name.value
765730
def get(key, default=-1):
        """"""
        if isinstance(key, int):
            return RegistrationFailure(key)
        if key not in RegistrationFailure._member_map_:
            extend_enum(RegistrationFailure, key, default)
        return RegistrationFailure[key]