def test_json_parse(file_r_name, path_w):
parsed = []
with open(file_r_name, 'r') as file_r, \
open(path_w + 'json_parse.json', 'w') as file_w:
for line in file_r:
line_parse = lem.json_parse(line)
parsed.append(line_parse)
pretty_json(parsed, file_w)
print('Done test_json_parse')
def test_build_edge_dict(file_r_name, file_weights_name, path_w):
# default
with open(file_r_name, 'r') as file_json, \
open(path_w + 'edges.json', 'w') as file_w:
edge_dict = lem.build_edge_dict(file_json)
edges = {' - '.join(edge): count for edge, count in edge_dict.items()}
pretty_json(edges, file_w)
# different options
path_w += 'options/'
if not os.path.exists(path_w):
os.makedirs(path_w)
weights_options = (None, True)
bastard_options = (True, False)
non_cyrillic_options = (True, False)
for weights in weights_options:
for bastard in bastard_options:
for non_cyrillic in non_cyrillic_options:
with open(file_r_name, 'r') as file_json:
if weights:
file_weights = open(file_weights_name, 'r')
else:
file_weights = None
file_w_name = '{0}edges (' \
'weights={1}, ' \
'bastard={2}, ' \
'non_cyrillic={3}' \
').json'.format(path_w, weights,
bastard, non_cyrillic)
file_w = open(file_w_name, 'w')
edge_dict = lem.build_edge_dict(file_json, file_weights,
bastard, non_cyrillic)
edges = {' - '.join(edge): count for edge, count in
edge_dict.items()}
pretty_json(edges, file_w)
print('Done test_build_edge_dict')
file_nodes_json_name = path_w + 'nodes.json'
file_edges_json_name = path_w + 'edges.json'
# Создаём узлы
with open(file_json_name, 'r') as file_json, \
open(file_weight_name, 'r') as file_weight, \
open(file_nodes_name, 'w') as file_nodes, \
open(file_nodes_json_name, 'w') as file_nodes_json:
# создаём словарь узлов
node_dict = lem.build_node_dict(file_json, weights=file_weight,
include_bastard=bastard,
include_non_cyrillic=non_cyrillic)
# записываем узлы в файл для Gephi
lem.write_node_dict(file_nodes, node_dict)
# отдельно сохраняем json-версию словаря узлов (для отладки)
pretty_json(node_dict, file_nodes_json)
# Создаём рёбра
with open(file_json_name, 'r') as file_json, \
open(file_weight_name, 'r') as file_weight, \
open(file_edges_name, 'w') as file_edges, \
open(file_edges_json_name, 'w') as file_edges_json:
# создаём словарь рёбер
edge_dict = lem.build_edge_dict(file_json, weights=file_weight,
include_bastard=bastard,
include_non_cyrillic=non_cyrillic)
# записываем рёбра в файл для Gephi
lem.write_edge_dict(file_edges, edge_dict)
# отдельно сохраняем json-версию словаря рёбер (для отладки)
edges = {' - '.join(edge): count for edge, count in edge_dict.items()}
pretty_json(edges, file_edges_json)
def make_gephi_files(file_data_name='data/input.txt',
path_r='data/', path_w='output/',
query_column=1, weight_column=None, sep='\t',
headers=False, mystem='/Applications/mystem',
bastard=True, non_cyrillic=True,
nodes_cut=0, edges_cut=0):
"""
Функция верхнего уровня для создания файлов узлов и рёбер для Gephi.
Позволяет сделать всё "в один клик" с настройками по умолчанию.
Все параметры необязательные.
:param file_data_name: файл с данными (по умолчанию data/input.txt)
:param path_r: путь к папке с данными (сюда будут сохраняться промежуточные
файлы с запросами и весами)
:param path_w: путь к папке, куда будут записываться все финальные файлы
:param query_column: номер столбца с запросами (по умолчанию 1)
:param weight_column: номер столбца с весами (по умолчанию отсуствует,
т.е. каждому запросу будет присвоен единичный вес)
:param sep: разделитель столбцов (по умолчанию '\t')
:param headers: есть ли в файле заголовки (по умолчанию False)
:param mystem: см. функцию lem
:param bastard: см. функцию lem_filter
:param non_cyrillic: см. функцию lem_filter
:param nodes_cut: см. функцию write_node_dict
:param edges_cut: см. функцию write_edge_dict
"""
if not os.path.exists(path_r):
os.makedirs(path_r)
if not os.path.exists(path_w):
os.makedirs(path_w)
# Параметры по умолчанию
params = ['-cldige', 'utf-8', '--format', 'json']
path_r = path_r.rstrip('/') + '/'
file_query_name = path_r + 'queries.txt'
file_weight_name = path_r + 'weights.txt'
path_w = path_w.rstrip('/') + '/'
file_lems_name = path_w + 'lems.txt'
file_json_name = path_w + 'lems.json'
file_nodes_name = path_w + 'nodes.csv'
file_edges_name = path_w + 'edges.csv'
file_nodes_json_name = path_w + 'nodes.json'
file_edges_json_name = path_w + 'edges.json'
# Сохраняем столбцы с запросами и весами в отдельные файлы
with open(file_data_name, 'r') as file_data, \
open(file_query_name, 'w') as file_query, \
open(file_weight_name, 'w') as file_weight:
if headers:
next(file_data)
for line in file_data:
line = line.rstrip('\n').split(sep)
print(line[query_column - 1], file=file_query)
if weight_column:
print(line[weight_column - 1], file=file_weight)
else:
print(1, file=file_weight)
# Прогоняем через леммер
with open(file_query_name, 'r') as file_query, \
open(file_json_name, 'w') as file_json:
lem(file_query, file_json, mystem=mystem, params=params)
# Список лемм для каждой исходной строки (для проверки)
with open(file_json_name, 'r') as file_json, \
open(file_lems_name, 'w') as file_lems:
for line in file_json:
line_parse = json_parse(line)
words = lem_filter(line_parse, include_bastard=bastard,
include_non_cyrillic=non_cyrillic)
lems = [word['lex'] for word in words]
print(' '.join(lems), file=file_lems)
# Создаём словари узлов и рёбер
# Узлы
with open(file_json_name, 'r') as file_json, \
open(file_weight_name, 'r') as file_weight:
node_dict = build_node_dict(file_json, weights=file_weight,
include_bastard=bastard,
include_non_cyrillic=non_cyrillic)
# Рёбра
with open(file_json_name, 'r') as file_json, \
open(file_weight_name, 'r') as file_weight:
edge_dict = build_edge_dict(file_json, weights=file_weight,
include_bastard=bastard,
include_non_cyrillic=non_cyrillic)
# Сохраняем словари в json-файлы
# Узлы
with open(file_nodes_json_name, 'w') as file_nodes_json:
pretty_json(node_dict, file_nodes_json)
# Рёбра
with open(file_edges_json_name, 'w') as file_edges_json:
edges = {' - '.join(edge): count for edge, count in edge_dict.items()}
pretty_json(edges, file_edges_json)
# Записываем словари для Gephi
# Узлы
with open(file_nodes_name, 'w') as file_nodes:
write_node_dict(file_nodes, node_dict, sep=';', cut=nodes_cut)
# Рёбра
with open(file_edges_name, 'w') as file_edges:
write_edge_dict(file_edges, edge_dict, sep=';', cut=edges_cut)