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_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 _filter_records_by_modules(memory_storage_inst, modules, releases):
selected = set([])
for m, r in vault.resolve_modules(modules, releases):
y = memory_storage_inst.get_record_ids_by_modules([m])
if r:
x = memory_storage_inst.get_record_ids_by_releases([r])
selected |= x & y
else:
selected |= y
return selected
def _filter_records_by_modules(memory_storage_inst, modules, releases):
selected = set([])
for m, r in vault.resolve_modules(modules, releases):
y = memory_storage_inst.get_record_ids_by_modules([m])
if r:
x = memory_storage_inst.get_record_ids_by_releases([r])
selected |= x & y
else:
selected |= y
return selected
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 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):
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 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))
time_filter = _get_time_filter(kwargs)
kwargs['records'] = time_filter(
memory_storage_inst.get_records(record_ids))
return f(*args, **kwargs)
