示例#1
0
class FormatTable(object):
    
    def __init__(self):
        
        self.helper = FormatHelper(True)
        self.default_formats = self.helper.default_formats

    def build(self, results, fields, row_order=None):

        data = []        
        description = {}    
        columns_order = []
        
        for field in fields:
            label = field.get('label', field['name'].replace('_', ' ').title())
            data_type = field.get('data_type', 'number')
            description[field['name']] = (data_type, label)
        
        for field in fields:
            columns_order.append(field['name'])

        if row_order is None:
            row_order = []
            for field in fields:
                name = field['name']                
                is_key_col = field.get('is_key_col', False)
                if is_key_col:
                     row_order.append({'name': name})           
        
        for result in results:

            row = {}
            value = result['value']

            for field in fields:
                name = field['name']                
                is_key_col = field.get('is_key_col', False)

                if is_key_col:
                     data_type = field.get('data_type', 'number')
                     key_value = result['_id'][name]
                     
                     if data_type == 'date':
                        key_value = datetime.strptime(key_value, '%Y/%m/%d')
                     row[name] = key_value
                else:                
                    row[name] = self.helper.format(value[name], field)

            data.append(row)

        for col in reversed(row_order):
            data.sort(key=lambda item:item[col['name']], reverse=col.get('reverse', False))
        
        return {
            'data':data, 
            'description':description,
            'columns_order': tuple(columns_order)
        }
示例#2
0
 def __init__(self):
     
     self.helper = FormatHelper(True)
     self.default_formats = self.helper.default_formats
示例#3
0
class FormatCombo(object):

    def __init__(self):
        
        self.helper = FormatHelper()
        self.default_formats = self.helper.default_formats

    def build(self, results, fields, group, split=None):
        
        data = []
        data_key = {}
        description = {}
        columns_order = []

        single_field = True if len(fields) == 1 else False
        
        group_name = group['name']
        group_data_type = group.get('data_type', 'date')
        group_label = group.get('label', group['name'].replace('_', ' ').title())

        description[group_name] = (group_data_type, group_label) 
        columns_order = [group_name]

        for result in results:
            
            key = result['_id'][group_name]
            prefix = result['_id'].get(split, None)
            value = result['value']

            for field in fields:
                name = field['name']
               
                if prefix is None:
                    line_name = name
                    label = field.get('label', name.replace('_', ' ').title())
                elif single_field:
                    line_name = prefix
                    field_label = field.get('label', None)
                    
                    if type(field_label) is str:
                        label = "{} {}".format(prefix.title(), field_label)
                    elif type(field_label) is dict and prefix in field_label:
                        label = field_label[prefix]
                    else:
                        label = prefix.title()
                else:
                    line_name = "{}_{}".format(prefix, name)
                    label = " ".join([prefix, field.get('label', name.replace('_', ' ').title())])

                if key not in data_key:
                    key_value = key             
                    if group_data_type == 'date':
                        key_value = datetime.strptime(key, '%Y/%m/%d')
                    data_key[key] = {'idx': len(data)}
                    row = {group_name : key_value}
                    data.append(row)
                else:
                    row = data[data_key[key]['idx']]
                
                if line_name not in description:
                    columns_order.append(line_name)
                    data_type = field.get('data_type', 'number')
                    description[line_name] = (data_type, label)
                
                row[line_name] = self.helper.format(value[name], field)

        return {
            'data':data, 
            'description':description,
            'columns_order': tuple(columns_order)
        }
示例#4
0
class FormatAb(object):

    def __init__(self):
        
        self.helper = FormatHelper(True)
        self.change_formats = self.helper.change_formats
        self.default_formats = self.helper.default_formats

    def build(self, results, fields):

        data = []
        data_key = {}
        description = {}
        columns_order = []
        
        variations = []

        description['metric'] = ("string", "Metric")
        columns_order = ['metric']
        
        for result in results:
        
            for key in result['_id']:
                variation = result['_id'][key]
                if variation not in description:
                    variations.append(variation)
                    description[variation] = ('number', variation.replace('_', ' ').title())
                    change_key = "change_{}".format(variation)
                    description[change_key] = ("number", "% Change")

            value = result['value']
            
            for field in fields:
        
                name = field['name']
                meta = value[name]

                if name not in data_key:
                    data_key[name] = {'idx': len(data), 'calc_type': meta['calc']}
                    row = {'metric': field.get('label', name.replace('_', ' ').title())}
                    data.append(row)
                else:
                    row = data[data_key[name]['idx']]

                row[variation] = self.helper.format(value[name], field)

        control = variations[0]
        for key in data_key:
            idx = data_key[key]['idx']
            calc_type = data_key[key]['calc_type']
            data_format = field.get('format', self.change_formats['pct'])
            
            row = data[idx]
            for variation in variations:
                change_key = "change_{}".format(variation)
                
                if calc_type == 'sum':
                    if row[control][0] != 0:
                        change = (row[variation][0] / float(row[control][0])) - 1.0
                    else:
                        change = 0
                else:
                    if row[control][0] != 0:
                        change = (row[variation][0] / row[control][0]) - 1
                    else:
                        change = 0
                
                row[change_key] = (change, data_format.format(change))
                
                if variation not in columns_order:
                    columns_order.append(variation)
                    if variation != control:
                        columns_order.append(change_key)

        return {
            'data':data, 
            'description':description,
            'columns_order': tuple(columns_order)
        }