Beispiel #1
0
	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)
Beispiel #2
0
	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)
Beispiel #4
0
	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)