class SearchEngine:
"""
classe que considero a principal desse modulo. É a estrutura de dados que
contém os arquivos para o processamento da engine.
"""
def __init__(self):
self.tagger = Tagger('portugues')
def insert(self, files):
"""
Esse método tem como entrada um array de arquivos, retornando uma lista de indexação reversa.
"""
dataset = []
for f in files:
paragraph = sent_tokenize(f[1].lower())
for index, p in enumerate(paragraph):
words = word_tokenize(p)
classes = self.tagger.classify(words)
for c in classes:
if re.match('N', c[1]):
keysId = [item['_id'] for item in dataset]
print 'qtd chaves: ' + str(len(keysId))
if c[0] in keysId:
ind = keysId.index(c[0])
files = dataset[ind]
if os.path.basename(f[0]) in files.keys():
if not index in dataset[ind][os.path.basename(f[0])]:
dataset[ind][os.path.basename(f[0])].append(index)
else:
dataset[ind][os.path.basename(f[0])] = [index]
else:
dataset.append({'_id':c[0], os.path.basename(f[0]):[index]})
return dataset
def extract(self, data):
"""
Algoritmo de busca simples que retorna um tupla com os arquivos.
"""
print 'vim pelo método extract'
for d in data:
paragraphs = []
try:
d.pop('_id')
except KeyError:
'ok'
for k in d.keys(): # o [1:] para eliminar a primeira chave!
#path_name = os.path.abspath('backend')
path_name = os.path.abspath('backend') + '/texts/'
#text = open(path_name+'\\texts\\'+ k + '.txt').read().decode('utf-8')
# print path_name+'\\'+ k + '.txt'
text = open(path_name+ k + '.txt').read().decode('utf-8')
text_sent = sent_tokenize(text)
for index in d[k]:
paragraphs.append(text_sent[index])
print paragraphs
return set(paragraphs)
def genKeyWords(self, question):
questionToken = self.preProcess(question)
tagger = Tagger('portugues')
token = tagger.classify(questionToken)
keyList = []
for tok in token:
if tok[1] == 'N' or re.match('ADJ', tok[1]) or re.match('V', tok[1]):
keyList.append(tok)
print keyList
print len(keyList)
return keyList
def gen_opt(self, file_text):
'''
método que gera o novo texto.
cada palavra é classificada e concatenada com o tipo através do caractere /
depois, é concatenado com o retorno do synset.
'''
tagger = Tagger('portugues')
tok = word_tokenize(file_text.read().decode('utf-8'))
clas = tagger.classify(tok)
p_text = []
for c in clas:
if c[1] == 'N' or re.match('ADJ',c[1]) or re.match('V',c[1]) or c[1] == '.':
gen_set = self.gen_synset(c)
p_text.append(gen_set)
optimized_text = ' '.join(p_text)
return optimized_text
class SearchEngine:
"""
classe que considero a principal desse modulo. É a estrutura de dados que
contém os arquivos para o processamento da engine.
"""
def __init__(self):
# código para carregar o pickle
self.search_data = {}
self.load_data()
# carregando o tagger
self.tagger = Tagger('portugues')
def save(self):
output = open('data.pkl', 'wb')
dump(self.search_data, output)
output.close()
def insert(self, files):
"""
Esse método tem como entrada um array de arquivos e uma tupla de path e
retorna uma lista de indexação reversa.
"""
for f in files:
p_count = -1
paragraph = sent_tokenize(f.read().decode('utf-8').lower())
for p in paragraph:
p_count +=1
words = word_tokenize(p)
classes = self.tagger.classify(words)
for c in classes:
if re.match('N', c[1]):
if self.search_data.has_key(c[0]):
names = [n for n,_ in self.search_data[c[0]]]
if os.path.basename(f.name) in names:
self.search_data[c[0]][names.index(os.path.basename(f.name))][1].append(p_count)
else:
self.search_data[c[0]].append(((os.path.basename(f.name)),[p_count]))
else:
self.search_data.update({c[0]:[((os.path.basename(f.name)),[p_count])]})
self.save()
def search(self, name):
"""
Algoritmo de busca simples que retorna um tupla com os arquivos.
"""
if name in self.search_data:
files = self.search_data[name]
path_name = os.path.abspath('FriggAnswer')
text_files = []
if files is not None:
for f in files:
text = open(path_name+'\\texts\\'+f[0]).read().decode('utf-8-sig')
opt_text = open(path_name+'\\texts2\\'+f[0]).read().decode('utf-8-sig').lower()
opt_text_data = GenSearchText().get_opt(opt_text)
# tokenização
text_sent = sent_tokenize(text)
for i in f[1]:
element = (text_sent[i], opt_text_data[i]) # modificado aqui
text_files.append(element)
return set(text_files)
else:
return None
def load_data(self):
"""
função simples para carregar o arquivo
"""
path = os.path.abspath('FriggAnswer')+'/pickle/'
#path = os.path.abspath('pickle')+'\\'
input_data = open(path + 'data.pkl')
self.search_data = load(input_data)
input_data.close()
