Example #1
0
def create_single_analysis(input_values, config):
    keyword = clean_keyword(input_values['keywords'][0])

    query = create_single_query(keyword, input_values, input_values['limit'])
    database_result = execute_single_analysis_query(query, config, input_values['measure'])

    labels = list(database_result.keys())
    data = [{'y': value[1]['measure'], 'org_y': value[1]['measure']} for value in database_result.values()]

    return labels, [data], [database_result]
Example #2
0
def create_contrastive_analysis(input_values, config):
    keywords = list(map(lambda value: clean_keyword(value), input_values['keywords']))
    used_measure = input_values['measure']

    overlap_limit = int(input_values['overlap_limit'] / 100 * input_values['limit'])

    overlap_query = create_overlap_query(keywords[0], keywords[1], input_values)
    overlap = execute_contrastive_analysis_query(overlap_query, config, used_measure)

    global_limit = (input_values['limit'] - min(overlap_limit, len(overlap))) // 2

    results = []
    for k in keywords:
        single_query = create_single_query(k, input_values, global_limit, list(overlap.keys()))
        term = execute_single_analysis_query(single_query, config, used_measure)
        results.append(term)

    overlap = remove_overlap_excess(overlap, overlap_limit)
    labels = list(results[0].keys()) + list(overlap.keys()) + list(results[1].keys())[::-1]

    results = append_overlap(results, overlap)

    measure = list(map(lambda k: k[1]['measure'], chain(results[0].values(), results[1].values())))
    max_value = maximum(measure)
    min_value = minimum(measure)

    data = transform_to_logistic_curve(results, labels, min_value, max_value)

    measure = list(map(lambda k: k['y'], chain(data[0], data[1])))
    max_value_new = maximum(measure)
    min_value_new = minimum(measure)

    offset = int((max_value - abs(min_value)) * 0.03)
    data = rescale(data, min_value, max_value, min_value_new, max_value_new, offset)

    return labels, data, results