Verwenden Sie Scrapy, um die URLs auf der Webseite zu kriechen

Question

Ich verwende Scrapy, um Daten von bestimmten Websites zu extrahieren. Das Problem ist, dass meine Spinne nur die Webseite der ersten Start_urls kriechen kann, sondern die URLs auf der Webseite nicht kriechen können. Ich habe die gleiche Spinne genau kopiert:

    from scrapy.spider import BaseSpider
    from scrapy.contrib.linkextractors.sgml import SgmlLinkExtractor
    from scrapy.selector import HtmlXPathSelector
    from scrapy.http import Request
    from scrapy.utils.response import get_base_url
    from scrapy.utils.url import urljoin_rfc
    from nextlink.items import NextlinkItem

    class Nextlink_Spider(BaseSpider):
        name = "Nextlink"
        allowed_domains = ["Nextlink"]
        start_urls = ["http://www.dmoz.org/Computers/Programming/Languages/Python/Books/"]

    def parse(self, response):
        hxs = HtmlXPathSelector(response)
        sites = hxs.select('//body/div[2]/div[3]/div/ul/li[2]/a/@href')          
        for site in sites:
            relative_url = site.extract()
            url =  self._urljoin(response,relative_url)
            yield Request(url, callback = self.parsetext)

    def parsetext(self, response):
        log = open("log.txt", "a")
        log.write("test if the parsetext is called")
        hxs = HtmlXPathSelector(response)
        items = []
        texts = hxs.select('//div').extract()
        for text in texts:
            item = NextlinkItem()
            item['text'] = text
            items.append(item)
            log = open("log.txt", "a")
            log.write(text)
        return items

    def _urljoin(self, response, url):
        """Helper to convert relative urls to absolute"""
        return urljoin_rfc(response.url, url, response.encoding)

Ich benutze den log.txt, um zu testen, ob der ParsetExt genannt wird. Nachdem ich meine Spinne gestrichen hatte, gibt es im log.txt nichts.

Answer 1

Siehe hier:

http://readthedocs.org/docs/scrapy/en/latest/topics/spiders.html?highlight=alowed_domains#scrapy.spider.basespider.lowed_domains

erlaubt_domains

Eine optionale Liste von Zeichenfolgen, die Domänen enthalten, die diese Spinne kriechen darf. Anfragen nach URLs, die nicht zu den in dieser Liste angegebenen Domänennamen gehören, werden nicht befolgt, wenn Offsitemiddleware aktiviert ist.

Solange Sie die Offsitemiddleware in Ihren Einstellungen nicht aktiviert haben, spielt es keine Rolle und Sie können gehen allowed_domains komplett raus.

Überprüfen Sie die Einstellungen.py, ob die Offsitemiddleware aktiviert ist oder nicht. Es sollte nicht aktiviert werden, wenn Sie Ihrer Spinne zulassen möchten, dass Sie auf eine Domäne kriechen.

Answer 2

Ich denke, das Problem ist, dass Sie Scrapy nicht jeweils jeder kriechenden URL verfolgt haben. Für mein eigenes Blog habe ich einen CrawlSpider implementiert, der Linkextractor-basierte Regeln verwendet, um alle relevanten Links auf meinen Blogseiten zu extrahieren:

# -*- coding: utf-8 -*-

'''
*   This program is free software: you can redistribute it and/or modify
*   it under the terms of the GNU General Public License as published by
*   the Free Software Foundation, either version 3 of the License, or
*   (at your option) any later version.
*
*   This program is distributed in the hope that it will be useful,
*   but WITHOUT ANY WARRANTY; without even the implied warranty of
*   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
*   GNU General Public License for more details.
*
*   You should have received a copy of the GNU General Public License
*   along with this program.  If not, see <http://www.gnu.org/licenses/>.
*
*   @author Marcel Lange <info@ask-sheldon.com>
*   @package ScrapyCrawler 
 '''


from scrapy.spiders import CrawlSpider, Rule
from scrapy.linkextractors import LinkExtractor

import Crawler.settings
from Crawler.items import PageCrawlerItem


class SheldonSpider(CrawlSpider):
    name = Crawler.settings.CRAWLER_NAME
    allowed_domains = Crawler.settings.CRAWLER_DOMAINS
    start_urls = Crawler.settings.CRAWLER_START_URLS
    rules = (
        Rule(
            LinkExtractor(
                allow_domains=Crawler.settings.CRAWLER_DOMAINS,
                allow=Crawler.settings.CRAWLER_ALLOW_REGEX,
                deny=Crawler.settings.CRAWLER_DENY_REGEX,
                restrict_css=Crawler.settings.CSS_SELECTORS,
                canonicalize=True,
                unique=True
            ),
            follow=True,
            callback='parse_item',
            process_links='filter_links'
        ),
    )

    # Filter links with the nofollow attribute
    def filter_links(self, links):
        return_links = list()
        if links:
            for link in links:
                if not link.nofollow:
                    return_links.append(link)
                else:
                    self.logger.debug('Dropped link %s because nofollow attribute was set.' % link.url)
        return return_links

    def parse_item(self, response):
        # self.logger.info('Parsed URL: %s with STATUS %s', response.url, response.status)
        item = PageCrawlerItem()
        item['status'] = response.status
        item['title'] = response.xpath('//title/text()')[0].extract()
        item['url'] = response.url
        item['headers'] = response.headers
        return item

An https://www.ask-sheldon.com/build-a-website-crawler-using-scrapy-framework/ Ich habe ausführlich beschrieben, wie ich eine Website -Crawler implementiert habe, um meinen WordPress FullPage -Cache aufzuwärmen.

Answer 3

Meine Vermutung wäre diese Zeile:

allowed_domains = ["Nextlink"]

Dies ist keine Domain wie Domain.tld, daher würde sie alle Links ablehnen. Wenn Sie das Beispiel aus nehmen die Dokumentation: allowed_domains = ["dmoz.org"]