def _write_multiencode_stats(self, term, ftype, etype, numbers):
'''Escribe estadísticas de codificación de postings.
Args:
term (string): término al que corresponde la lista de números.
ftype (PostingFieldTypes): tipo de archivo de stats a escribir
(docs o freqs).
etype (EncodeTypes): codificación utilizada.
numbers (int list): números escritos con la codificación dado.
'''
writer = None
if ftype == PostingFieldTypes.Docs:
writer = self._multiencode_stats_docs_file
if not writer:
path = self._dirout + "//other//encoder_docs_statistics.txt"
utils.makedirs(os.path.dirname(path))
writer = open(path, "w")
self._multiencode_stats_docs_file = writer
else:
writer = self._multiencode_stats_freqs_file
if not writer:
path = self._dirout + "//other//encoder_freqs_statistics.txt"
utils.makedirs(os.path.dirname(path))
writer = open(path, "w")
self._multiencode_stats_freqs_file = writer
data = "Term: " + term + "; "
data += "EncodeType: " + str(etype.name) + "; "
data += "Numbers: " + str(numbers) + "\n"
writer.write(data)
def main(args):
'''Punto de entrada.'''
utils.makedirs(OUTPUT)
for fid in sorted(FILES_TO_ANALYZE):
print("Analizando {0}...".format(fid))
analyze(fid, FILES_TO_ANALYZE[fid])
def __merge_child_indexes(self):
'''Mergea los índices creados por los indexadores hijos.'''
utils.makedirs(self._dirout)
# Cálculo de cantidad de índices de los que se cargarán la información
# de chunks a RAM.
child_count = len(self.__child_indexes)
cdata_indexes_to_load = int(round(child_count*RESOURCES_FACTOR, 0))
print("\nMergeando...")
info = "Total de subíndices: {0} ({1}/{0} con chunks info en RAM)."
print(info.format(child_count, cdata_indexes_to_load))
print("Cargando subíndices...")
# Load de indexadores hijos.
for i in range(0, len(self.__child_indexes)):
index = self.__child_indexes[i]
if not index.is_loaded():
index.load(chunks_info_in_memory=cdata_indexes_to_load > 0)
cdata_indexes_to_load -= 1
info = "Subíndice {0}/{1} cargado."
print(info.format(i+1, child_count))
self.__merge_child_collections()
self.__merge_child_postings()
def __write_indexation_info(self, dirout):
'''Almacena información de subindexación en el dir de salida dado.
Args:
dirout (string): directorio de salida.
'''
utils.makedirs(dirout + "/other")
fstatus = open("{0}/status.txt".format(dirout + "/other"), "w")
info = "Creación de subíndice finalizada correctamente."
fstatus.write(info)
fstatus.close()
def test_indexes(self, chunks_info_in_memory=False):
'''Testea los índices especificados.
Args:
chunks_info_in_memory (bool): indica si la información de chunks se
debe cargar en RAM.
'''
self.__check_queries_load()
# Creación de directorio de out.
dirout = self.__base_dirout + "/indisk/"
if chunks_info_in_memory:
dirout = self.__base_dirout + "/inmemory/"
utils.makedirs(dirout)
for dirindex in self.__dirindexes:
self.test_index(dirindex, chunks_info_in_memory)
def _save(self, docs, terms, dirout):
'''Genera índice en base a dicts de docs y terms pasados por parámetro.
Args:
docs (dict): hash de documentos.
terms (dict): hash de términos.
dirout (string): directorio de salida de índice.
Returns:
index (Index): término generado.
'''
utils.makedirs(dirout)
index = Index(dirout)
super()._dump_docs_dict(docs, index)
self._dump_terms_dict(terms, index)
return index
def create_index(self, dirout, overwrite=False, chunk_size=0):
'''Realiza indexación en base a directorio de in.
Args:
dirout (string): directorio de salida.
overwrite (bool): indica si se debe sobrescribir el índice en caso
de que ya exista.
chunk_size (int): tamaño máximo de chunks de postings. Si es 1, la
posting se almacenará se almacenará 'contigua'.
Returns:
index (Index): índice generado.
status (IndexStatusTypes): cód. de estado respecto a la generación
del índice (ya indexado, directorio de in no existente, ok).
'''
print("Indexación en progreso...")
# Info de multicompresión.
doc_multiencode = isinstance(self.doc_encode, list)
freq_multiencode = isinstance(self.freq_encode, list)
self._multiencode = doc_multiencode or freq_multiencode
# Selección de caller de writer de encoded.
if doc_multiencode:
self._write_docs_caller = self._write_multiencode_block
else:
self._write_docs_caller = self._write_monoencode_block
if freq_multiencode:
self._write_freqs_caller = self._write_multiencode_block
else:
self._write_freqs_caller = self._write_monoencode_block
# Escritura de stats en caso de multiencode en docs y freqs.
if doc_multiencode and freq_multiencode:
self._has_to_write_multiencode_stats = True
# Directorio de salida de índice.
self._dirout = dirout
# Tamaño de chunk.
self._chunk_size = chunk_size
# Índice.
self.index = Index(self._dirout)
# Si ya existe el índice y no se permite sobre-escritura...
if self.index.exists() and not overwrite:
print("Ya indexado...\n")
# Retorno de índice + error de ya indexado.
return self.index, IndexerStatusTypes.Already_Indexed
# Si no existe dirin...
if not os.path.exists(self.__dirin):
print("Directorio de colección inexistente...\n")
# Retorna de null + error de colección no existente.
return self.index, IndexerStatusTypes.Collection_Non_Existent
# Si se deben reusar archivos temporales anteriores...
if self.__reuse_tmp:
self.__try_load_child_indexes()
if not self.__child_indexes:
print("Creando subíndices temporales...")
start = time.time()
self.__create_child_indexes()
end = time.time()
print("Tiempo de creación de subíndices temporales:", round(end-start, 2))
else:
print("Archivos de subíndices temporales existentes.")
start = time.time()
if self.__child_indexes:
self.__merge_child_indexes()
end = time.time()
else:
ex = "Imposible realizar merge de índice (not exists childs)"
raise Exception(ex)
info = ">> Tiempo de merge de índice: " + str(round(end-start, 2))
info += "\n\n>> Tamaño de archivos: "
info += "\nCollection: {0} MiB"
info += "\nChunks info: {1} MiB"
info += "\nVocabulary: {2} MiB"
info += "\nPostings: {3} MiB"
coll_size = ((os.path.getsize(self.index.collection_path))/1024)/1024
chin_size = ((os.path.getsize(self.index.chunksinfo_path))/1024)/1024
voca_size = ((os.path.getsize(self.index.vocabulary_path))/1024)/1024
post_size = ((os.path.getsize(self.index.postings_path))/1024)/1024
info = info.format(round(coll_size, 1), round(chin_size, 1),
round(voca_size, 1), round(post_size, 1))
print("\n" + info + "\n")
utils.makedirs(self._dirout + "//other/")
fstatus = open(self._dirout + "//other/status.txt", "w")
fstatus.write(info)
fstatus.close()
# Retorno de index y status = ok.
return self.index, IndexerStatusTypes.Ok
def main(args):
'''Punto de entrada.'''
utils.makedirs(OUTPUT_DIR)
analyze()