def get_modules_json(records): module_group_index = vault.get_vault()['module_group_index'] module_id_index = vault.get_vault()['module_id_index'] tags = parameters.get_parameter({}, 'tag', 'tags') # all modules mentioned in records module_ids = set(record['module'] for record in records) # plus all module groups that hold these modules module_ids |= set(itertools.chain.from_iterable( module_group_index.get(module, []) for module in module_ids)) # keep only modules with specified tags if tags: module_ids = set(module_id for module_id in module_ids if module_id_index[module_id].get('tag') in tags) # keep only modules that are in project type completely pts = parameters.get_parameter({}, 'project_type', 'project_types') if pts: m = set(vault.resolve_project_types(pts)) module_ids = set(module_id for module_id in module_ids if module_id_index[module_id]['modules'] <= m) query = (flask.request.args.get('query') or '').lower() matched = [] for module_id in module_ids: if module_id.find(query) >= 0: module = dict([(k, v) for k, v in six.iteritems(module_id_index[module_id]) if k not in ['modules']]) matched.append(module) return sorted(matched, key=operator.itemgetter('text'))
def timeline(records, **kwargs): # find start and end dates release_names = parameters.get_parameter(kwargs, "release", "releases") releases = vault.get_vault()["releases"] if not release_names: flask.abort(404) if "all" in release_names: start_date = release_start_date = utils.timestamp_to_week(vault.get_vault()["start_date"]) end_date = release_end_date = utils.timestamp_to_week(vault.get_vault()["end_date"]) else: release = releases[release_names[0]] start_date = release_start_date = utils.timestamp_to_week(release["start_date"]) end_date = release_end_date = utils.timestamp_to_week(release["end_date"]) now = utils.timestamp_to_week(int(time.time())) + 1 # expand start-end to year if needed if release_end_date - release_start_date < 52: expansion = (52 - (release_end_date - release_start_date)) // 2 if release_end_date + expansion < now: end_date += expansion else: end_date = now start_date = end_date - 52 # empty stats for all weeks in range weeks = range(start_date, end_date) week_stat_loc = dict((c, 0) for c in weeks) week_stat_commits = dict((c, 0) for c in weeks) week_stat_commits_hl = dict((c, 0) for c in weeks) param = parameters.get_parameter(kwargs, "metric") if ("commits" in param) or ("loc" in param): handler = lambda record: record["loc"] else: handler = lambda record: 0 # fill stats with the data for record in records: week = record["week"] if week in weeks: week_stat_loc[week] += handler(record) week_stat_commits[week] += 1 if "all" in release_names or record["release"] in release_names: week_stat_commits_hl[week] += 1 # form arrays in format acceptable to timeline plugin array_loc = [] array_commits = [] array_commits_hl = [] for week in weeks: week_str = utils.week_to_date(week) array_loc.append([week_str, week_stat_loc[week]]) array_commits.append([week_str, week_stat_commits[week]]) array_commits_hl.append([week_str, week_stat_commits_hl[week]]) return [array_commits, array_commits_hl, array_loc]
def get_modules_json(records): module_id_index = vault.get_vault()['module_id_index'] tags = parameters.get_parameter({}, 'tag', 'tags') # all modules mentioned in records module_ids = set(record['module'] for record in records if record['module'] in module_id_index) add_modules = set([]) for module in six.itervalues(module_id_index): if set(module['modules']) <= module_ids: add_modules.add(module['id']) module_ids |= add_modules # keep only modules with specified tags if tags: module_ids = set(module_id for module_id in module_ids if module_id_index[module_id].get('tag') in tags) query = (flask.request.args.get('query') or '').lower() matched = [] for module_id in module_ids: if module_id.find(query) >= 0: module = dict([(k, v) for k, v in six.iteritems(module_id_index[module_id]) if k not in ['modules']]) module['text'] = module['module_group_name'] del module['module_group_name'] matched.append(module) return sorted(matched, key=operator.itemgetter('text'))
def get_engineers(records, metric_filter, finalize_handler): exclude = flask.request.args.get('exclude') modules_names = parameters.get_parameter({}, 'module', 'modules') modules = vault.resolve_modules(modules_names) def filter_core_users(record): user = vault.get_user_from_runtime_storage(record['id']) is_core = False for (module, branch) in user['core']: if module in modules: is_core = branch if branch == 'master': # we need master, but stables are ok break if exclude: if ((exclude == 'non-core' and is_core) or (exclude == 'core' and not is_core)): return record else: record['core'] = is_core return record return _get_aggregated_stats(records, metric_filter, vault.get_memory_storage().get_user_ids(), 'user_id', 'author_name', finalize_handler=finalize_handler, postprocessing=filter_core_users)
def get_modules_json(record_ids, **kwargs): module_id_index = vault.get_vault()["module_id_index"] tags = parameters.get_parameter({}, "tag", "tags") # all modules mentioned in records module_ids = vault.get_memory_storage().get_index_keys_by_record_ids("module", record_ids) add_modules = set([]) for module in six.itervalues(module_id_index): if set(module["modules"]) & module_ids: add_modules.add(module["id"]) module_ids |= add_modules # keep only modules with specified tags if tags: module_ids = set( module_id for module_id in module_ids if ((module_id in module_id_index) and (module_id_index[module_id].get("tag") in tags)) ) result = [] for module_id in module_ids: module = module_id_index[module_id] result.append({"id": module["id"], "text": module["module_group_name"], "tag": module["tag"]}) return sorted(result, key=operator.itemgetter("text"))
def get_modules_json(records): module_id_index = vault.get_vault()['module_id_index'] tags = parameters.get_parameter({}, 'tag', 'tags') # all modules mentioned in records module_ids = set(record['module'] for record in records if record['module'] in module_id_index) add_modules = set([]) for module in six.itervalues(module_id_index): if set(module['modules']) <= module_ids: add_modules.add(module['id']) module_ids |= add_modules # keep only modules with specified tags if tags: module_ids = set(module_id for module_id in module_ids if module_id_index[module_id].get('tag') in tags) query = (flask.request.args.get('query') or '').lower() matched = [] for module_id in module_ids: if module_id.find(query) >= 0: module = dict([ (k, v) for k, v in six.iteritems(module_id_index[module_id]) if k not in ['modules'] ]) module['text'] = module['module_group_name'] del module['module_group_name'] matched.append(module) return sorted(matched, key=operator.itemgetter('text'))
def get_modules_json(record_ids, **kwargs): module_id_index = vault.get_vault()['module_id_index'] tags = parameters.get_parameter({}, 'tag', 'tags') # all modules mentioned in records module_ids = vault.get_memory_storage().get_index_keys_by_record_ids( 'module', record_ids) add_modules = set([]) for module in six.itervalues(module_id_index): if set(module['modules']) & module_ids: add_modules.add(module['id']) module_ids |= add_modules # keep only modules with specified tags if tags: module_ids = set(module_id for module_id in module_ids if ((module_id in module_id_index) and (module_id_index[module_id].get('tag') in tags))) result = [] for module_id in module_ids: module = module_id_index[module_id] result.append({'id': module['id'], 'text': module['module_group_name'], 'tag': module['tag']}) return sorted(result, key=operator.itemgetter('text'))
def timeline(records, **kwargs): # find start and end dates release_name = parameters.get_single_parameter(kwargs, 'release') or 'all' releases = vault.get_vault()['releases'] if 'all' in release_name: start_date = release_start_date = _get_date(kwargs, 'start_date') end_date = release_end_date = _get_date(kwargs, 'end_date') else: release = releases[release_name] start_date = release_start_date = utils.timestamp_to_week( release['start_date']) end_date = release_end_date = utils.timestamp_to_week( release['end_date']) now = utils.timestamp_to_week(int(time.time())) + 1 # expand start-end to year if needed if release_end_date - release_start_date < 52: expansion = (52 - (release_end_date - release_start_date)) // 2 if release_end_date + expansion < now: end_date += expansion else: end_date = now start_date = end_date - 52 # empty stats for all weeks in range weeks = range(start_date, end_date) week_stat_loc = dict((c, 0) for c in weeks) week_stat_commits = dict((c, 0) for c in weeks) week_stat_commits_hl = dict((c, 0) for c in weeks) param = parameters.get_parameter(kwargs, 'metric') if ('commits' in param) or ('loc' in param): handler = lambda record: record['loc'] else: handler = lambda record: 0 # fill stats with the data for record in records: week = record['week'] if week in weeks: week_stat_loc[week] += handler(record) week_stat_commits[week] += 1 if 'all' == release_name or record['release'] == release_name: week_stat_commits_hl[week] += 1 # form arrays in format acceptable to timeline plugin array_loc = [] array_commits = [] array_commits_hl = [] for week in weeks: week_str = utils.week_to_date(week) array_loc.append([week_str, week_stat_loc[week]]) array_commits.append([week_str, week_stat_commits[week]]) array_commits_hl.append([week_str, week_stat_commits_hl[week]]) return [array_commits, array_commits_hl, array_loc]
def test_parameters_get_parameter(self, get_default, flask_request): flask_request.args = mock.Mock() flask_request.args.get = mock.Mock(side_effect=lambda x: x) def make(values=None): def f(arg): return values.get(arg, None) if values else None return f get_default.side_effect = make() flask_request.args.get.side_effect = make({"param": "foo"}) self.assertEqual(["foo"], parameters.get_parameter({"param": "foo"}, "param")) flask_request.args.get.side_effect = make({"param": "foo"}) self.assertEqual(["foo"], parameters.get_parameter({}, "param")) flask_request.args.get.side_effect = make({"param": "foo"}) self.assertEqual([], parameters.get_parameter({}, "other", use_default=False)) flask_request.args.get.side_effect = make({"params": "foo"}) self.assertEqual(["foo"], parameters.get_parameter({}, "param", plural_name="params")) flask_request.args.get.side_effect = make({}) get_default.side_effect = make({"param": "foo"}) self.assertEqual(["foo"], parameters.get_parameter({}, "param")) self.assertEqual([], parameters.get_parameter({}, "other"))
def test_parameters_get_parameter(self, get_default, flask_request): flask_request.args = mock.Mock() flask_request.args.get = mock.Mock(side_effect=lambda x: x) def make(values=None): def f(arg): return values.get(arg, None) if values else None return f get_default.side_effect = make() flask_request.args.get.side_effect = make({'param': 'foo'}) self.assertEqual(['foo'], parameters.get_parameter( {'param': 'foo'}, 'param')) flask_request.args.get.side_effect = make({'param': 'foo'}) self.assertEqual(['foo'], parameters.get_parameter({}, 'param')) flask_request.args.get.side_effect = make({'param': 'foo'}) self.assertEqual([], parameters.get_parameter( {}, 'other', use_default=False)) flask_request.args.get.side_effect = make({'params': 'foo'}) self.assertEqual(['foo'], parameters.get_parameter( {}, 'param', plural_name='params')) flask_request.args.get.side_effect = make({}) get_default.side_effect = make({'param': 'foo'}) self.assertEqual(['foo'], parameters.get_parameter({}, 'param')) self.assertEqual([], parameters.get_parameter({}, 'other'))
def make_link(title, uri=None, options=None): param_names = ('release', 'project_type', 'module', 'company', 'user_id', 'metric') param_values = {} for param_name in param_names: v = parameters.get_parameter({}, param_name, param_name) if v: param_values[param_name] = ','.join(v) if options: param_values.update(options) if param_values: uri += '?' + '&'.join(['%s=%s' % (n, utils.safe_encode(v)) for n, v in six.iteritems(param_values)]) return '<a href="%(uri)s">%(title)s</a>' % {'uri': uri, 'title': title}
def make_link(title, uri=None, options=None): param_names = ('release', 'project_type', 'module', 'company', 'user_id', 'metric') param_values = {} for param_name in param_names: v = parameters.get_parameter({}, param_name, param_name) if v: param_values[param_name] = ','.join(v) if options: param_values.update(options) if param_values: uri += '?' + '&'.join(['%s=%s' % (n, safe_encode(v)) for n, v in param_values.iteritems()]) return '<a href="%(uri)s">%(title)s</a>' % {'uri': uri, 'title': title}
def get_engineers_extended(records): modules_names = parameters.get_parameter({}, 'module', 'modules') modules = vault.resolve_modules(modules_names) def postprocessing(record): record = decorators.mark_finalize(record) if not (record['mark'] or record['review'] or record['commit'] or record['email'] or record['patch_count']): return user = vault.get_user_from_runtime_storage(record['id']) record['company'] = user['companies'][-1]['company_name'] record['core'] = get_core_engineer_branch(user, modules) return record def record_processing(result, record, param_id): result_row = result[record[param_id]] record_type = record['record_type'] result_row[record_type] = result_row.get(record_type, 0) + 1 if record_type == 'mark': decorators.mark_filter(result, record, param_id) if record_type == 'review': result_row['patch_count'] = (result_row.get('patch_count', 0) + record['patch_count']) result = {} for record in records: user_id = record['user_id'] if user_id not in result: result[user_id] = { 'id': user_id, 'mark': 0, 'review': 0, 'commit': 0, 'email': 0, 'patch_count': 0, 'metric': 0 } record_processing(result, record, 'user_id') result[user_id]['name'] = record['author_name'] response = result.values() response = [item for item in map(postprocessing, response) if item] response.sort(key=lambda x: x['metric'], reverse=True) utils.add_index(response) return response
def get_engineers(records, metric_filter, finalize_handler): modules_names = parameters.get_parameter({}, 'module', 'modules') modules = vault.resolve_modules(modules_names) def postprocessing(record): if finalize_handler: record = finalize_handler(record) user = vault.get_user_from_runtime_storage(record['id']) record['core'] = get_core_engineer_branch(user, modules) return record return _get_aggregated_stats(records, metric_filter, vault.get_memory_storage().get_user_ids(), 'user_id', 'author_name', finalize_handler=postprocessing)
def get_engineers(records, metric_filter, finalize_handler): modules_names = parameters.get_parameter({}, 'module', 'modules') modules = vault.resolve_modules(modules_names) def postprocessing(record): if finalize_handler: record = finalize_handler(record) user = vault.get_user_from_runtime_storage(record['id']) record['core'] = is_engineer_core_in_modules(user, modules) return record return _get_aggregated_stats(records, metric_filter, vault.get_memory_storage().get_user_ids(), 'user_id', 'author_name', finalize_handler=postprocessing)
def get_engineers_extended(records): modules_names = parameters.get_parameter({}, 'module', 'modules') modules = vault.resolve_modules(modules_names) def postprocessing(record): record = decorators.mark_finalize(record) if not (record['mark'] or record['review'] or record['commit'] or record['email'] or record['patch_count']): return user = vault.get_user_from_runtime_storage(record['id']) record['company'] = user['companies'][-1]['company_name'] record['core'] = get_core_engineer_branch(user, modules) return record def record_processing(result, record, param_id): result_row = result[record[param_id]] record_type = record['record_type'] result_row[record_type] = result_row.get(record_type, 0) + 1 if record_type == 'mark': decorators.mark_filter(result, record, param_id) if record_type == 'review': result_row['patch_count'] = (result_row.get('patch_count', 0) + record['patch_count']) result = {} for record in records: user_id = record['user_id'] if user_id not in result: result[user_id] = {'id': user_id, 'mark': 0, 'review': 0, 'commit': 0, 'email': 0, 'patch_count': 0, 'metric': 0} record_processing(result, record, 'user_id') result[user_id]['name'] = record['author_name'] response = result.values() response = [item for item in map(postprocessing, response) if item] response.sort(key=lambda x: x['metric'], reverse=True) utils.add_index(response) return response
def get_engineers(records, metric_filter, finalize_handler, **kwargs): modules_names = parameters.get_parameter({}, "module", "modules") modules = set([m for m, r in vault.resolve_modules(modules_names, [""])]) def postprocessing(record): if finalize_handler: record = finalize_handler(record) user = vault.get_user_from_runtime_storage(record["id"]) record["core"] = get_core_engineer_branch(user, modules) return record return _get_aggregated_stats( records, metric_filter, vault.get_memory_storage().get_user_ids(), "user_id", "author_name", finalize_handler=postprocessing, )
def _prepare_params(kwargs, ignore): params = kwargs.get('_params') if not params: params = {'action': flask.request.path} for key in parameters.FILTER_PARAMETERS: params[key] = parameters.get_parameter(kwargs, key, key) if params['start_date']: params['start_date'] = [utils.round_timestamp_to_day( params['start_date'][0])] if params['end_date']: params['end_date'] = [utils.round_timestamp_to_day( params['end_date'][0])] kwargs['_params'] = params if ignore: return dict([(k, v if k not in ignore else []) for k, v in six.iteritems(params)]) else: return params
def _prepare_params(kwargs, ignore): params = kwargs.get('_params') if not params: params = {'action': flask.request.path} for key in parameters.FILTER_PARAMETERS: params[key] = parameters.get_parameter(kwargs, key, key) if params['start_date']: params['start_date'] = [ utils.round_timestamp_to_day(params['start_date'][0]) ] if params['end_date']: params['end_date'] = [ utils.round_timestamp_to_day(params['end_date'][0]) ] kwargs['_params'] = params if ignore: return dict([(k, v if k not in ignore else []) for k, v in six.iteritems(params)]) else: return params
def get_engineers_extended(records, **kwargs): modules_names = parameters.get_parameter({}, "module", "modules") modules = set([m for m, r in vault.resolve_modules(modules_names, [""])]) def postprocessing(record): record = decorators.mark_finalize(record) if not (record["mark"] or record["review"] or record["commit"] or record["email"] or record["patch"]): return user = vault.get_user_from_runtime_storage(record["id"]) record["company"] = user["companies"][-1]["company_name"] record["core"] = get_core_engineer_branch(user, modules) return record def record_processing(result, record, param_id): result_row = result[record[param_id]] record_type = record["record_type"] result_row[record_type] = result_row.get(record_type, 0) + 1 if record_type == "mark": decorators.mark_filter(result, record, param_id) result = {} for record in records: user_id = record["user_id"] if user_id not in result: result[user_id] = {"id": user_id, "mark": 0, "review": 0, "commit": 0, "email": 0, "patch": 0, "metric": 0} record_processing(result, record, "user_id") result[user_id]["name"] = record["author_name"] response = result.values() response = [item for item in map(postprocessing, response) if item] response.sort(key=lambda x: x["metric"], reverse=True) utils.add_index(response) return response
def record_filter_decorated_function(*args, **kwargs): memory_storage_inst = vault.get_memory_storage() record_ids = set(memory_storage_inst.get_record_ids()) # a copy releases = [] if 'release' not in ignore: releases = parameters.get_parameter(kwargs, 'release', 'releases', use_default) if releases: if 'all' not in releases: record_ids &= ( memory_storage_inst.get_record_ids_by_releases( c.lower() for c in releases)) modules = parameters.get_parameter(kwargs, 'module', 'modules', use_default) if 'project_type' not in ignore: param = parameters.get_parameter(kwargs, 'project_type', 'project_types', use_default) if param: record_ids &= _filter_records_by_modules( memory_storage_inst, vault.resolve_project_types(param), releases) if 'module' not in ignore: if modules: record_ids &= _filter_records_by_modules( memory_storage_inst, modules, releases) if 'user_id' not in ignore: param = parameters.get_parameter(kwargs, 'user_id', 'user_ids') param = [u for u in param if vault.get_user_from_runtime_storage(u)] if param: record_ids &= ( memory_storage_inst.get_record_ids_by_user_ids(param)) if 'company' not in ignore: param = parameters.get_parameter(kwargs, 'company', 'companies') if param: record_ids &= ( memory_storage_inst.get_record_ids_by_companies(param)) if 'metric' not in ignore: metrics = parameters.get_parameter(kwargs, 'metric') if 'all' not in metrics: for metric in metrics: if metric in parameters.METRIC_TO_RECORD_TYPE: record_ids &= ( memory_storage_inst.get_record_ids_by_type( parameters.METRIC_TO_RECORD_TYPE[metric])) if 'tm_marks' in metrics: filtered_ids = [] review_nth = int(parameters.get_parameter( kwargs, 'review_nth')[0]) for record in memory_storage_inst.get_records(record_ids): parent = memory_storage_inst.get_record_by_primary_key( record['review_id']) if (parent and ('review_number' in parent) and (parent['review_number'] <= review_nth)): filtered_ids.append(record['record_id']) record_ids = filtered_ids if 'blueprint_id' not in ignore: param = parameters.get_parameter(kwargs, 'blueprint_id') if param: record_ids &= ( memory_storage_inst.get_record_ids_by_blueprint_ids( param)) time_filter = _get_time_filter(kwargs, ignore) kwargs['records'] = time_filter( memory_storage_inst.get_records(record_ids)) return f(*args, **kwargs)
def timeline(records, **kwargs): # find start and end dates metric = parameters.get_parameter(kwargs, 'metric') start_date = int(parameters.get_single_parameter(kwargs, 'start_date') or 0) release_name = parameters.get_single_parameter(kwargs, 'release') or 'all' releases = vault.get_vault()['releases'] if 'all' in release_name: start_week = release_start_week = _get_week(kwargs, 'start_date') end_week = release_end_week = _get_week(kwargs, 'end_date') else: release = releases[release_name] start_week = release_start_week = utils.timestamp_to_week( release['start_date']) end_week = release_end_week = utils.timestamp_to_week( release['end_date']) now = utils.timestamp_to_week(int(time.time())) + 1 # expand start-end to year if needed if release_end_week - release_start_week < 52: expansion = (52 - (release_end_week - release_start_week)) // 2 if release_end_week + expansion < now: end_week += expansion else: end_week = now start_week = end_week - 52 # empty stats for all weeks in range weeks = range(start_week, end_week) week_stat_loc = dict((c, 0) for c in weeks) week_stat_commits = dict((c, 0) for c in weeks) week_stat_commits_hl = dict((c, 0) for c in weeks) if ('commits' in metric) or ('loc' in metric): handler = lambda record: record['loc'] else: handler = lambda record: 0 # fill stats with the data if 'man-days' in metric: # special case for man-day effort metric release_stat = collections.defaultdict(set) all_stat = collections.defaultdict(set) for record in records: if ((record['record_type'] == 'commit') or (record['week'] not in weeks)): continue day = utils.timestamp_to_day(record['date']) user = vault.get_user_from_runtime_storage(record['user_id']) if record['release'] == release_name: release_stat[day] |= set([user['seq']]) all_stat[day] |= set([user['seq']]) for day, users in six.iteritems(release_stat): week = utils.timestamp_to_week(day * 24 * 3600) week_stat_commits_hl[week] += len(users) for day, users in six.iteritems(all_stat): week = utils.timestamp_to_week(day * 24 * 3600) week_stat_commits[week] += len(users) else: for record in records: week = record['week'] if week in weeks: week_stat_loc[week] += handler(record) week_stat_commits[week] += 1 if 'members' in metric: if record['date'] >= start_date: week_stat_commits_hl[week] += 1 else: if record['release'] == release_name: week_stat_commits_hl[week] += 1 if 'all' == release_name and 'members' not in metric: week_stat_commits_hl = week_stat_commits # form arrays in format acceptable to timeline plugin array_loc = [] array_commits = [] array_commits_hl = [] for week in weeks: week_str = utils.week_to_date(week) array_loc.append([week_str, week_stat_loc[week]]) array_commits.append([week_str, week_stat_commits[week]]) array_commits_hl.append([week_str, week_stat_commits_hl[week]]) return [array_commits, array_commits_hl, array_loc]
def record_filter_decorated_function(*args, **kwargs): vault_inst = vault.get_vault() memory_storage_inst = vault.get_memory_storage() record_ids = set(memory_storage_inst.get_record_ids()) # a copy if 'module' not in ignore: param = parameters.get_parameter(kwargs, 'module', 'modules', use_default) if param: record_ids &= ( memory_storage_inst.get_record_ids_by_modules( vault.resolve_modules(param))) if 'project_type' not in ignore: param = parameters.get_parameter(kwargs, 'project_type', 'project_types', use_default) if param: ptgi = vault_inst['project_type_group_index'] modules = set() for project_type in param: project_type = project_type.lower() if project_type in ptgi: modules |= ptgi[project_type] record_ids &= ( memory_storage_inst.get_record_ids_by_modules(modules)) if 'user_id' not in ignore: param = parameters.get_parameter(kwargs, 'user_id', 'user_ids') param = [ u for u in param if vault.get_user_from_runtime_storage(u) ] if param: record_ids &= ( memory_storage_inst.get_record_ids_by_user_ids(param)) if 'company' not in ignore: param = parameters.get_parameter(kwargs, 'company', 'companies') if param: record_ids &= ( memory_storage_inst.get_record_ids_by_companies(param)) if 'release' not in ignore: param = parameters.get_parameter(kwargs, 'release', 'releases', use_default) if param: if 'all' not in param: record_ids &= ( memory_storage_inst.get_record_ids_by_releases( c.lower() for c in param)) if 'metric' not in ignore: metrics = parameters.get_parameter(kwargs, 'metric') if 'all' not in metrics: for metric in metrics: record_ids &= ( memory_storage_inst.get_record_ids_by_type( parameters.METRIC_TO_RECORD_TYPE[metric])) if 'tm_marks' in metrics: filtered_ids = [] review_nth = int( parameters.get_parameter(kwargs, 'review_nth')[0]) for record in memory_storage_inst.get_records(record_ids): parent = memory_storage_inst.get_record_by_primary_key( record['review_id']) if (parent and ('review_number' in parent) and (parent['review_number'] <= review_nth)): filtered_ids.append(record['record_id']) record_ids = filtered_ids if 'blueprint_id' not in ignore: param = parameters.get_parameter(kwargs, 'blueprint_id') if param: record_ids &= (memory_storage_inst. get_record_ids_by_blueprint_ids(param)) kwargs['records'] = memory_storage_inst.get_records(record_ids) return f(*args, **kwargs)
def timeline(records, **kwargs): # find start and end dates metric = parameters.get_parameter(kwargs, 'metric') start_date = int(parameters.get_single_parameter(kwargs, 'start_date') or 0) release_name = parameters.get_single_parameter(kwargs, 'release') or 'all' releases = vault.get_vault()['releases'] if 'all' in release_name: start_week = release_start_week = _get_week(kwargs, 'start_date') end_week = release_end_week = _get_week(kwargs, 'end_date') else: release = releases[release_name] start_week = release_start_week = utils.timestamp_to_week( release['start_date']) end_week = release_end_week = utils.timestamp_to_week( release['end_date']) now = utils.timestamp_to_week(int(time.time())) + 1 # expand start-end to year if needed if release_end_week - release_start_week < 52: expansion = (52 - (release_end_week - release_start_week)) // 2 if release_end_week + expansion < now: end_week += expansion else: end_week = now start_week = end_week - 52 # empty stats for all weeks in range weeks = range(start_week, end_week) week_stat_loc = dict((c, 0) for c in weeks) week_stat_commits = dict((c, 0) for c in weeks) week_stat_commits_hl = dict((c, 0) for c in weeks) if ('commits' in metric) or ('loc' in metric): handler = lambda record: record['loc'] else: handler = lambda record: 0 # fill stats with the data if 'man-days' in metric: # special case for man-day effort metric release_stat = collections.defaultdict(set) all_stat = collections.defaultdict(set) for record in records: if ((record['record_type'] == 'commit') or (record['week'] not in weeks)): continue day = record['date'] // (24 * 3600) user = vault.get_user_from_runtime_storage(record['user_id']) if record['release'] == release_name: release_stat[day] |= set([user['seq']]) all_stat[day] |= set([user['seq']]) for day, users in six.iteritems(release_stat): week = utils.timestamp_to_week(day * 24 * 3600) week_stat_commits_hl[week] += len(users) for day, users in six.iteritems(all_stat): week = utils.timestamp_to_week(day * 24 * 3600) week_stat_commits[week] += len(users) else: for record in records: week = record['week'] if week in weeks: week_stat_loc[week] += handler(record) week_stat_commits[week] += 1 if 'members' in metric: if record['date'] >= start_date: week_stat_commits_hl[week] += 1 else: if record['release'] == release_name: week_stat_commits_hl[week] += 1 if 'all' == release_name and 'members' not in metric: week_stat_commits_hl = week_stat_commits # form arrays in format acceptable to timeline plugin array_loc = [] array_commits = [] array_commits_hl = [] for week in weeks: week_str = utils.week_to_date(week) array_loc.append([week_str, week_stat_loc[week]]) array_commits.append([week_str, week_stat_commits[week]]) array_commits_hl.append([week_str, week_stat_commits_hl[week]]) return [array_commits, array_commits_hl, array_loc]
def timeline(records, **kwargs): # find start and end dates metric = parameters.get_parameter(kwargs, "metric") start_date = int(parameters.get_single_parameter(kwargs, "start_date") or 0) release_name = parameters.get_single_parameter(kwargs, "release") or "all" releases = vault.get_vault()["releases"] if "all" in release_name: start_week = release_start_week = _get_week(kwargs, "start_date") end_week = release_end_week = _get_week(kwargs, "end_date") else: release = releases[release_name] start_week = release_start_week = utils.timestamp_to_week(release["start_date"]) end_week = release_end_week = utils.timestamp_to_week(release["end_date"]) now = utils.timestamp_to_week(int(time.time())) + 1 # expand start-end to year if needed if release_end_week - release_start_week < 52: expansion = (52 - (release_end_week - release_start_week)) // 2 if release_end_week + expansion < now: end_week += expansion else: end_week = now start_week = end_week - 52 # empty stats for all weeks in range weeks = range(start_week, end_week) week_stat_loc = dict((c, 0) for c in weeks) week_stat_commits = dict((c, 0) for c in weeks) week_stat_commits_hl = dict((c, 0) for c in weeks) if ("commits" in metric) or ("loc" in metric): handler = lambda record: record["loc"] else: handler = lambda record: 0 # fill stats with the data if "man-days" in metric: # special case for man-day effort metric release_stat = collections.defaultdict(set) all_stat = collections.defaultdict(set) for record in records: if (record["record_type"] == "commit") or (record["week"] not in weeks): continue day = utils.timestamp_to_day(record["date"]) user = vault.get_user_from_runtime_storage(record["user_id"]) if record["release"] == release_name: release_stat[day] |= set([user["seq"]]) all_stat[day] |= set([user["seq"]]) for day, users in six.iteritems(release_stat): week = utils.timestamp_to_week(day * 24 * 3600) week_stat_commits_hl[week] += len(users) for day, users in six.iteritems(all_stat): week = utils.timestamp_to_week(day * 24 * 3600) week_stat_commits[week] += len(users) else: for record in records: week = record["week"] if week in weeks: week_stat_loc[week] += handler(record) week_stat_commits[week] += 1 if "members" in metric: if record["date"] >= start_date: week_stat_commits_hl[week] += 1 else: if record["release"] == release_name: week_stat_commits_hl[week] += 1 if "all" == release_name and "members" not in metric: week_stat_commits_hl = week_stat_commits # form arrays in format acceptable to timeline plugin array_loc = [] array_commits = [] array_commits_hl = [] for week in weeks: week_str = utils.week_to_date(week) array_loc.append([week_str, week_stat_loc[week]]) array_commits.append([week_str, week_stat_commits[week]]) array_commits_hl.append([week_str, week_stat_commits_hl[week]]) return [array_commits, array_commits_hl, array_loc]
def record_filter_decorated_function(*args, **kwargs): memory_storage_inst = vault.get_memory_storage() record_ids = set(memory_storage_inst.get_record_ids()) # a copy params = _prepare_params(kwargs, ignore) release = params['release'] if release: if 'all' not in release: record_ids &= ( memory_storage_inst.get_record_ids_by_releases( c.lower() for c in release)) project_type = params['project_type'] if project_type: record_ids &= _filter_records_by_modules( memory_storage_inst, vault.resolve_project_types(project_type), release) module = params['module'] if module: record_ids &= _filter_records_by_modules( memory_storage_inst, module, release) user_id = params['user_id'] user_id = [ u for u in user_id if vault.get_user_from_runtime_storage(u) ] if user_id: record_ids &= ( memory_storage_inst.get_record_ids_by_user_ids(user_id)) company = params['company'] if company: record_ids &= ( memory_storage_inst.get_record_ids_by_companies(company)) metric = params['metric'] if 'all' not in metric: for metric in metric: if metric in parameters.METRIC_TO_RECORD_TYPE: record_ids &= ( memory_storage_inst.get_record_ids_by_type( parameters.METRIC_TO_RECORD_TYPE[metric])) if 'tm_marks' in metric: filtered_ids = [] review_nth = int( parameters.get_parameter(kwargs, 'review_nth')[0]) for record in memory_storage_inst.get_records(record_ids): parent = memory_storage_inst.get_record_by_primary_key( record['review_id']) if (parent and ('review_number' in parent) and (parent['review_number'] <= review_nth)): filtered_ids.append(record['record_id']) record_ids = filtered_ids blueprint_id = params['blueprint_id'] if blueprint_id: record_ids &= (memory_storage_inst. get_record_ids_by_blueprint_ids(blueprint_id)) start_date = params['start_date'] end_date = params['end_date'] if start_date or end_date: record_ids &= _filter_records_by_days(start_date, end_date, memory_storage_inst) kwargs['record_ids'] = record_ids kwargs['records'] = memory_storage_inst.get_records(record_ids) return f(*args, **kwargs)
def record_filter_decorated_function(*args, **kwargs): memory_storage_inst = vault.get_memory_storage() record_ids = set(memory_storage_inst.get_record_ids()) # a copy params = _prepare_params(kwargs, ignore) release = params['release'] if release: if 'all' not in release: record_ids &= ( memory_storage_inst.get_record_ids_by_releases( c.lower() for c in release)) project_type = params['project_type'] if project_type: record_ids &= _filter_records_by_modules( memory_storage_inst, vault.resolve_project_types(project_type), release) module = params['module'] if module: record_ids &= _filter_records_by_modules( memory_storage_inst, module, release) user_id = params['user_id'] user_id = [u for u in user_id if vault.get_user_from_runtime_storage(u)] if user_id: record_ids &= ( memory_storage_inst.get_record_ids_by_user_ids(user_id)) company = params['company'] if company: record_ids &= ( memory_storage_inst.get_record_ids_by_companies(company)) metric = params['metric'] if 'all' not in metric: for metric in metric: if metric in parameters.METRIC_TO_RECORD_TYPE: record_ids &= ( memory_storage_inst.get_record_ids_by_type( parameters.METRIC_TO_RECORD_TYPE[metric])) if 'tm_marks' in metric: filtered_ids = [] review_nth = int(parameters.get_parameter( kwargs, 'review_nth')[0]) for record in memory_storage_inst.get_records(record_ids): parent = memory_storage_inst.get_record_by_primary_key( record['review_id']) if (parent and ('review_number' in parent) and (parent['review_number'] <= review_nth)): filtered_ids.append(record['record_id']) record_ids = filtered_ids blueprint_id = params['blueprint_id'] if blueprint_id: record_ids &= ( memory_storage_inst.get_record_ids_by_blueprint_ids( blueprint_id)) start_date = params['start_date'] end_date = params['end_date'] if start_date or end_date: record_ids &= _filter_records_by_days(start_date, end_date, memory_storage_inst) kwargs['record_ids'] = record_ids kwargs['records'] = memory_storage_inst.get_records(record_ids) return f(*args, **kwargs)