Return a dictionary of this collection's values where the keys are the moys.

        This is useful for aligning the values with another list of datetimes.
497387
def moys_dict(self):
        
        moy_dict = {}
        for val, dt in zip(self.values, self.datetimes):
            moy_dict[dt.moy] = val
        return moy_dict
525217
def values(self, key_type=None):
        
        if(key_type is not None):
            all_items = {} # in order to preserve keys() type (dict_values for python3) 
            keys_used = set()
            direct_key = str(key_type)
            if direct_key in self.__dict__:
                for intermediate_key in self.__dict__[direct_key].values():
                    if not intermediate_key in keys_used:
                        all_items[intermediate_key] = self.items_dict[intermediate_key]
                        keys_used.add(intermediate_key)
            return all_items.values()
        else:
            return self.items_dict.values()
7503
def multi_groupby(self, key_fn):
        
        result_dict = defaultdict(list)

        for x in self:
            for key in key_fn(x):
                result_dict[key].append(x)

        # convert result lists into same Collection type as this one
        return {
            k: self.clone_with_new_elements(elements)
            for (k, elements)
            in result_dict.items()
        }
1110358
def _dict_subset(keys, master_dict):
    '''
    
    '''
    return dict([(k, v) for k, v in six.iteritems(master_dict) if k in keys])
747003
def values(self, dtype, dates, sids):
        
        shape = (len(dates), len(sids))
        return {
            datetime64ns_dtype: self._datetime_values,
            float64_dtype: self._float_values,
            int64_dtype: self._int_values,
            bool_dtype: self._bool_values,
            object_dtype: self._object_values,
        }[dtype](shape)
452145
def values(self):
        
        if self._values is None:
            self._values = self.calculateValues()
        return self._values
486656
def collections(record, key, value):
    """"""
    return {
        'primary': value.get('a'),
        'secondary': value.get('b'),
        'deleted': value.get('c'),
    }
1091470
def keys(self):
        
        keys = []
        for val in self.form.scales.values():
            keys += val.dtype.fields.keys()
        return keys
337447
def keys(self):
        
        return_value = []
        for s in self.serializers:
            return_value += s.content_type
        return return_value
763258
def items(self):
        ''''''
        return [(self.keys[x], self.values[x]) for x in range(len(self.keys))]
247343
def filter(self, **kwargs):
        
        keys = self.filter_keys(**kwargs)
        return self.keys_to_values(keys)
963920
def match_to_dict(self, match, gids):
        
        values = {}
        for gid in gids:
            try:
                values[gid] = self.map_value(match.group(gid), gid)
            except IndexError:
                pass
        return values
422499
def DictKeyColumns(d):
    ''
    return [ColumnItem(k, k, type=deduceType(d[k])) for k in d.keys()]
881510
def values(self):
        
        self.expired()
        values = []
        for key in self._dict.keys():
            try:
                value = self._dict[key].get()
                values.append(value)
            except:
                continue
        return values
654022
def get_datetime_properties(self, recursive=True):
        
        res = {}
        for name, field in self.properties.items():
            if isinstance(field, DateField):
                res[name] = field
            elif recursive and isinstance(field, ObjectField):
                for n, f in field.get_datetime_properties(recursive=recursive):
                    res[name + "." + n] = f
        return res
1252352
def to_python(self):
        
        result = dict(self)

        for key, value in iteritems(result):
            if isinstance(value, DottedCollection):
                result[key] = value.to_python()

        return result
462585
def dict(self):
        
        d = {p.key: getattr(self, p.key) for p in self.__mapper__.attrs
             if p.key not in ('contents', 'dataset')}

        d['modified_datetime'] = self.modified_datetime
        d['modified_ago'] = self.modified_ago

        return d