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 get_context():
    keyword = clean_keyword(loads(request.values['keyword']))
    co_occurring_word = request.values['cooccurrence']

    cursor = g.posgre_db.cursor()
    cursor.execute("""select S.sentence from sentences S where S.id in
                    (select sentenceId from inv_w I where
                    I.wordId in (select id from words where word IN (%s, %s))
                    group by I.sentenceId
                    having count(distinct I.wordId) = 2
                    );""", (keyword, co_occurring_word))

    result = cursor.fetchall()
    cursor.close()
    return jsonify(tweets=result)
Example #3
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