Returns a list of dictionary of valis value for this setting.
170627
def _getEnumValues(self, data):
        
        enumstr = data.attrib.get('enumValues')
        if not enumstr:
            return None
        if ':' in enumstr:
            return {self._cast(k): v for k, v in [kv.split(':') for kv in enumstr.split('|')]}
        return enumstr.split('|')
711526
def _convert_to_dict(self, setting):
        '''
        
        '''
        the_dict = {}
        set = dir(setting)
        for key in set:
            if key in self.ignore:
                continue
            value = getattr(setting, key)
            the_dict[key] = value

        return the_dict
689935
def __get_values(self):
        """"""
        values = []

        if self.__remote:
            description = self.__client.describe(self.__point)
            if description is not None:
                if description['type'] != 'Point':
                    raise IOTUnknown('%s is not a Point' % self.__point)
                values = description['meta']['values']
        else:
            limit = 100
            offset = 0
            while True:
                new = self.__point.list(limit=limit, offset=offset)
                values += new
                if len(new) < limit:
                    break
                offset += limit

            # Unlike for describe, value comments are keyed by language here, so unwrap to have same layout as for
            # describe call (default language only, if available).
            lang = self.__client.default_lang
            for value in values:
                value['comment'] = value['comment'].get(lang, None) if value['comment'] else None

        return values
911842
def values(self):
        
        dtypes = [col.dtype for col in self.columns]
        if len(set(dtypes)) > 1:
            dtype = object
        else:
            dtype = None
        return np.array(self.columns, dtype=dtype).T
1242968
def values(self):
        ""
        return (list(self._pb.IntMap.values()) + list(self._pb.StringMap.values()) +
                list(self._pb.FloatMap.values()) + list(self._pb.BoolMap.values()))
1029756
def list2dict(list_of_options):
    """"""
    d = {}
    for key, value in list_of_options:
        d[key] = value
    return d
273209
def values(self):
        
        return [
            (
                np.array(dim.numeric_values)
                if (dim.numeric_values and any(~np.isnan(dim.numeric_values)))
                else None
            )
            for dim in self._slice.dimensions
        ]
799240
def unpack_hyperopt_vals(vals):
    
    assert isinstance(vals, dict), "Parameter must be given as dict."
    ret = {}
    for k, v in list(vals.items()):
        try:
            ret[k] = v[0]
        except (TypeError, IndexError):
            ret[k] = v
    return ret
763258
def items(self):
        ''''''
        return [(self.keys[x], self.values[x]) for x in range(len(self.keys))]
1003320
def allval(self):
        

        d = dict(self.__dict__.items())
        d['sl'] = self.sl

        d[self.level] = 0

        cls = self.get_class(self.sl)

        return cls(**d)
607493
def list(self):
        
        settings = []
        for setting in _SETTINGS:
            value = self.get(setting)
            is_set = self.is_set(setting)
            default_value = self.get_default_value(setting)
            is_supported = True
            settings.append((setting, value, default_value, is_set, is_supported))
        for setting in sorted(self.settings_state.list_keys()):
            if not self.is_supported(setting):
                value = self.get(setting)
                default_value = None
                is_set = True
                is_supported = False
                settings.append((setting, value, default_value, is_set, is_supported))
        return settings
188547
def get_values(self):
        """"""
        for value_name, widget in self.index.items():
            self.value[value_name] = widget.get_value(self.value[value_name])

            setting_name = self.widget + '/' + value_name
            settings.setValue(setting_name, self.value[value_name])
471034
def values(self):
        """"""
        values = []
        for __, data in self.items():
            values.append(data)
        return values
1211773
def scalarcoords(self):
        """"""
        return {k: v.values for k, v in self.coords.items() if v.dims==()}
1332354
def values(self, key=_absent):
        
        if key is not _absent and key in self._map:
            return self.getlist(key)
        return list(self.itervalues())
459871
def dict(self):
        
        odict = {}
        for arg in _arg_names:
            value = getattr(self, arg)
            # Do not attempt to store preset option values in presets
            if arg in ('add_preset', 'del_preset', 'desc', 'note'):
                value = None
            odict[arg] = value
        return odict
912014
def get(self):
        
        return {k:v for k,v in list(self.options.items()) if k in self._allowed_axes}