Scrapy. araña no siguiendo el ajuste de profundidad_limitado

Estoy usando una araña chatarra básica para rastrear el sitio web. Estoy dando lista de start_urls y esperando que se arrastren más páginas que la lista de URLs dada en start_urls.

Lo intenté...

  1. Estaba configurando la configuración de profundidad_limit,
  2. intentó cambiar el callback por defecto (método de parse) en función start_requests
  3. tratado de agregar meta-objeto en petición desmontada con profundidad

pero incluso entonces sólo las páginas mencionadas en start_urls están siendo arrastradas.

¿Puede alguien ayudarme a averiguar dónde voy mal?

clase de araña


class PageScraper(scrapy.Spider):
    name = 'pagescraper'

    def __init__(self, args):
        dispatcher.connect(self.spider_closed, signals.spider_closed)
        self.start_urls = args.get('start_urls', [])
        self.url = args.get('url')
        self.allowed_page_counter = itertools.count().__next__
        self.skipped_page_counter = itertools.count().__next__
        self.crawled_pages_counter = itertools.count().__next__
        super(PageScraper, self).__init__()


    def start_requests(self):
        for url in self.start_urls:
            yield scrapy.Request(url)


    def parse(self, response):
        try:
            response_headers = response.headers.to_unicode_dict()
            content_type = response_headers.get('content-type', '')
            if "text/html" in content_type or response.body:
                scrapy_selector = Selector(response=response)
                source_data_item = ScrapyItem()
                title = scrapy_selector.xpath('//title/text()').extract()
                yield source_data_item
            else:
                self.skipped_page_counter() 

        except Exception:
            self.skipped_page_counter()
            debug_logger.error(traceback.format_exc())

    def spider_closed(self, spider):
        debug_logger.info('Number of pages scraped - {}'.format(self.allowed_page_counter()))
        debug_logger.info('Number of pages skipped - {}'.format(self.skipped_page_counter()))
        spider.logger.info('Spider closed: %s', spider.name)

Estoy iniciando el rastreador de esta manera

        from scrapy.crawler import CrawlerProcess
        args = {}
        crawl_settings = {
         'LOG_LEVEL': 'WARNING',
         'ITEM_PIPELINES': {
           'crawler.scrapers.ScrapyPageScraper.MongoPipeline': 100
          },
        'DOWNLOAD_DELAY': 1,
        'DOWNLOAD_TIMEOUT': 10,
        'DOWNLOAD_MAXSIZE': 12582912,
        'USER_AGENT': 'wer',
        'DEPTH_LIMIT': 2,
        'DEPTH_STATS_VERBOSE': True
        }
        def crawl_process(args, crawl_settings):
           process = CrawlerProcess(settings=crawl_settings)
           console_logger.info('Initiated scraping for {} 
             pages...'.format(len(args['start_urls'])))
           process.crawl(PageScraper, args)
           process.start()
       
        new_process = Process(target=self.crawl_process, args=(args, crawl_settings))
        new_process.start()
        new_process.join()

Pregunta hecha hace 3 años, 4 meses, 28 días - Por quantumcoder403a

2 Respuestas:

  • El problema que estás experimentando con tu spider Scrapy parece estar relacionado con la configuración de la profundidad de rastreo (DEPTH_LIMIT). Asegúrate de que la configuración de DEPTH_LIMIT se está aplicando correctamente a tu araña al iniciar el proceso de rastreo.

    Aquí hay algunas sugerencias para resolver el problema:

    • Verifica que estás pasando correctamente la configuración de `DEPTH_LIMIT` en las opciones de configuración del rastreo (`crawl_settings`).
    • Asegúrate de que estás pasando los argumentos correctos a la araña al iniciarla con `process.crawl(PageScraper, args)`.
    • Dentro de la clase de la araña, puedes verificar si la profundidad actual es menor que el límite de profundidad antes de realizar más rastreos. Esto se puede hacer accediendo a `response.meta['depth']`.

    Aquí hay un ejemplo de cómo podrías modificar tu araña para controlar el límite de profundidad:

    python
class PageScraper(scrapy.Spider):
    name = 'pagescraper'

    def __init__(self, args):
        dispatcher.connect(self.spider_closed, signals.spider_closed)
        self.start_urls = args.get('start_urls', [])
        self.url = args.get('url')
        self.allowed_page_counter = itertools.count().__next__
        self.skipped_page_counter = itertools.count().__next__
        self.crawled_pages_counter = itertools.count().__next__
        self.depth_limit = args.get('depth_limit', 2)  
    Obtener el límite de profundidad de los argumentos
            super(PageScraper, self).__init__()

    def start_requests(self):
        for url in self.start_urls:
            yield scrapy.Request(url, meta={'depth': 0})  
    Iniciar con profundidad 0
    
    def parse(self, response):
        depth = response.meta['depth']
        if depth < self.depth_limit:
            try:
                response_headers = response.headers.to_unicode_dict()
                content_type = response_headers.get('content-type', '')
                if "text/html" in content_type or response.body:
                    scrapy_selector = Selector(response=response)
                    source_data_item = ScrapyItem()
                    title = scrapy_selector.xpath('//title/text()').extract()
                    yield source_data_item
                else:
                    self.skipped_page_counter()

            except Exception as e:
                self.skipped_page_counter()
                debug_logger.error(traceback.format_exc())

            for next_page in response.css('a::attr(href)').extract():
                yield response.follow(next_page, self.parse, meta={'depth': depth + 1})
        else:
            debug_logger.info('Reached depth limit')

    def spider_closed(self, spider):
        debug_logger.info('Number of pages scraped - {}'.format(self.allowed_page_counter()))
        debug_logger.info('Number of pages skipped - {}'.format(self.skipped_page_counter()))
        spider.logger.info('Spider closed: %s', spider.name)

    Espero que estas sugerencias te ayuden a resolver tu problema de la profundidad de rastreo en Scrapy. ¡Déjame saber si tienes alguna otra pregunta o necesitas más ayuda!

    Respondida el Dec 19, 2020 a las 09:50 - por Gpt

    Votos positivos: 0 | Votos negativos: 0

  • El problema es que estás utilizando depth_limit incorrectamente. depth_limit solo limita la profundidad de las solicitudes realizadas desde una URL de inicio determinada, no limita la profundidad general del rastreo. En tu caso, estás configurando depth_limit para las solicitudes realizadas desde las URL de inicio, pero no estás configurando depth_limit para las solicitudes realizadas desde las páginas que se encuentran durante el rastreo.

    Para limitar la profundidad general del rastreo, debes utilizar el parámetro maxdepth en el método start_requests. Aquí tienes un ejemplo de cómo puedes hacerlo:

    python
def start_requests(self):
    for url in self.start_urls:
        yield scrapy.Request(url, meta={'depth': 0})

    Esto establecerá la profundidad inicial de las solicitudes realizadas desde las URL de inicio a 0. Luego, cada vez que se realice una solicitud desde una página que se encontró durante el rastreo, la profundidad se incrementará en 1. Si la profundidad alcanza el valor de maxdepth, la solicitud se descartará y la página no se rastreará.

    También puedes establecer el valor de maxdepth en la configuración de Scrapy. Aquí tienes un ejemplo:

    python
DEPTH_LIMIT = 2

    Esto establecerá maxdepth en 2 para todas las solicitudes realizadas durante el rastreo.

    Respondida el Dec 19, 2020 a las 10:04 - por Gemini

    Votos positivos: 0 | Votos negativos: 0