def __process_items(self, to_process):
"Procesa los items"
self.log("Comenzando procesado. Usando %d browsers" %
self.get_paralel_num())
# crea el pool de browsers
self.__browser_pool = _BrowserPool()
for _ in range(self.get_paralel_num()):
self.__browser_pool.add_browser(self.__get_browser(
self.get_process_item_browser_type()
)
)
# pone a procesar todos los items
progress = eta.Progress(len(to_process), unit = "pag")
pipeline = ItemProcesorPipeline(self.get_paralel_num())
start = time()
# convierte los items a una lista para tenerlos todos antes de
# agregarlos al pipeline
to_process = list(to_process)
for item_manager_item in to_process:
# print "pusheando %d" % item_manager_item.item_num
pipeline.push(self.__process_item_call_sequence,
item_manager_item,
len(to_process),
progress,
pipeline
)
pipeline.wait_end() # espera a que termine de procesar
processing_time_str = eta.time_string(time() - start)
self.log("Procesamiento terminado en %s" % processing_time_str)
def __make_paging_call_sequence(self):
"hace el paginado y chequea la respuesta"
self.log("Comenzado paginado")
start = time()
browser = self.__get_browser(self.get_paging_browser_type())
paging_res = self.make_paging(MakePagingContext(self.__context,browser))
# chequea el tipo de los elementos retornados
if not hasattr(paging_res, '__iter__'):
raise TypeError("make_paging() returned %s, but it must return a" +\
" list" % type(paging_res).__name__)
# chequea uno a uno los elementos retornados
for paged_item in paging_res:
if not isinstance(paged_item, Item):
raise TypeError("make_paging must return a list of Item " +\
"objects, but it returned an item of type %s" % (
type(paged_item).__name__))
paging_time = time() - start
self.log("Fin paginado, en %s . Obtenidos %s items" %
(eta.time_string(paging_time), len(paging_res)) )
# agrega los items
self.__item_manager.add(paging_res)
return paging_res
def __finalize_call_sequence(self, page_manager):
"Llama a finalize y amigos"
processed = page_manager.get_processed_items()
unprocessed = page_manager.get_unprocessed_items()
starttime = time()
msg = "Comenzando finalizacion. Procesados %d items, "
msg += "no procesados %d items"
self.log(msg % (len(processed), len(unprocessed)))
try:
self.on_finalize(processed, unprocessed)
except:
e_str = self.__handle_last_error("Error en llamada a finalize()")
page_manager.add_error(-1, e_str)
ellapsed = eta.time_string(time() - starttime)
self.log("Finalizacion completada en %s" % ellapsed)
def __finalize_call_sequence(self):
"Hace todo lo necesario para la llamada a finalize, si corresponde"
starttime = time()
processed_items = self.__item_manager.stored_processed_items
unprocessed_items = self.__item_manager.stored_unprocessed_items
msg = "Comenzando finalización. Procesados %d items, "
msg += "no procesados %d items"
self.log(msg % (len(processed_items), len(unprocessed_items)))
try:
self.finalize(FinalizeContext(self.__context),
processed_items,
unprocessed_items)
except:
e_str = self.__handle_last_error("Error en llamada a finalize()")
self.__item_manager.add_error(-1, e_str)
ellapsed = eta.time_string(time() - starttime)
self.log("Finalización completada en %s" % ellapsed)
def __process_pages(self, page_manager):
"Procesa las páginas"
paralel_num = self.get_paralel_num()
if paralel_num == 1:
self.log("Comenzando procesado. Usando un browser")
else:
self.log("Comenzando procesado. Usando %d browsers" % paralel_num)
pipeline = ItemProcesorPipeline(paralel_num)
start = time()
progress = Progress(0, "pagina")
page_manager.on_add_page_suscribe(_AddPageListener(
pipeline,
self.__process_page_call_sequence,
progress
)
)
while True:
pending_page = page_manager.get_pending_page()
if pending_page == None:
break
pipeline.push(
self.__process_page_call_sequence,
page_manager,
pending_page,
pipeline,
progress
)
pipeline.wait_end() # espera a que termine de procesar
processing_time_str = eta.time_string(time() - start)
self.log("Procesamiento terminado en %s" % processing_time_str)