Le scrapy peut-il être utilisé pour extraire du contenu dynamique de sites Web utilisant AJAX?

J'ai récemment appris Python et je me suis lancé dans la construction d'un web-grattoir. Il n'y a rien d'extraordinaire du tout; son seul objectif est de récupérer les données d'un site de paris et de les mettre dans Excel.

La plupart des problèmes peuvent être résolus et j'ai un bon petit désordre. Cependant, je rencontre un énorme obstacle sur un problème. Si un site charge une table de chevaux et répertorie les prix actuels des paris, cette information ne se trouve dans aucun fichier source. L'indice est que ces données sont parfois en direct, les chiffres étant évidemment mis à jour à partir d'un serveur distant. Le HTML sur mon PC a simplement un trou où leurs serveurs transmettent toutes les données intéressantes dont j'ai besoin.

Maintenant, mon expérience avec le contenu Web dynamique est faible, donc cette chose est quelque chose que j'ai du mal à comprendre.

Je pense que Java ou Javascript est une clé, cela apparaît souvent.

Le grattoir est simplement un moteur de comparaison de cotes. Certains sites ont des API mais j'en ai besoin pour ceux qui n'en ont pas. J'utilise la bibliothèque scrapy avec Python 2.7

Je m'excuse si cette question est trop ouverte. En bref, ma question est la suivante: comment le scrapy peut-il être utilisé pour gratter ces données dynamiques afin que je puisse les utiliser? Pour que je puisse récupérer ces données de cotes de paris en temps réel?

Les navigateurs basés sur Webkit (comme Google Chrome ou Safari) ont des outils de développement intégrés. Dans Chrome, vous pouvez l'ouvrir Menu->Tools->Developer Tools. L' Networkonglet vous permet de voir toutes les informations sur chaque demande et réponse:

En bas de l'image, vous pouvez voir que j'ai filtré la demande jusqu'à XHR- ce sont des demandes faites par code javascript.

Astuce: le journal est effacé à chaque fois que vous chargez une page, en bas de l'image, le bouton point noir conservera le journal.

Après avoir analysé les demandes et les réponses, vous pouvez simuler ces demandes à partir de votre robot d'exploration et extraire des données précieuses. Dans de nombreux cas, il sera plus facile d'obtenir vos données que d'analyser du HTML, car ces données ne contiennent pas de logique de présentation et sont formatées pour être accessibles par du code javascript.

Firefox a une extension similaire, elle s'appelle firebug . Certains diront que firebug est encore plus puissant mais j'aime la simplicité du webkit.

Voici un exemple simple de scrapyavec une requête AJAX. Voyons le site rubin-kazan.ru .

Tous les messages sont chargés avec une requête AJAX. Mon objectif est de récupérer ces messages avec tous leurs attributs (auteur, date, ...):

Lorsque j'analyse le code source de la page, je ne vois pas tous ces messages car la page Web utilise la technologie AJAX. Mais je peux avec Firebug de Mozilla Firefox (ou un outil équivalent dans d'autres navigateurs) pour analyser la requête HTTP qui génère les messages sur la page Web:

Il ne recharge pas la page entière mais seulement les parties de la page qui contiennent des messages. Pour cela, je clique sur un nombre arbitraire de page en bas:

Et j'observe la requête HTTP qui est responsable du corps du message:

Après avoir terminé, j'analyse les en-têtes de la requête (je dois citer que cette URL que je vais extraire de la page source de la section var, voir le code ci-dessous):

Et le contenu des données du formulaire de la requête (la méthode HTTP est "Post"):

Et le contenu de la réponse, qui est un fichier JSON:

Qui présente toutes les informations que je recherche.

Désormais, je dois mettre en œuvre toutes ces connaissances dans la scrapy. Définissons l'araignée à cet effet:

class spider(BaseSpider):
    name = 'RubiGuesst'
    start_urls = ['http://www.rubin-kazan.ru/guestbook.html']

    def parse(self, response):
        url_list_gb_messages = re.search(r'url_list_gb_messages="(.*)"', response.body).group(1)
        yield FormRequest('http://www.rubin-kazan.ru' + url_list_gb_messages, callback=self.RubiGuessItem,
                          formdata={'page': str(page + 1), 'uid': ''})

    def RubiGuessItem(self, response):
        json_file = response.body

En parsefonction j'ai la réponse pour la première demande. Dans RubiGuessItemj'ai le fichier JSON avec toutes les informations.

Plusieurs fois, lors de l'exploration, nous rencontrons des problèmes où le contenu rendu sur la page est généré avec Javascript et donc scrapy est incapable de l'explorer (par exemple, requêtes ajax, folie jQuery).

Cependant, si vous utilisez Scrapy avec le framework de test Web Selenium, nous sommes en mesure d'explorer tout ce qui est affiché dans un navigateur Web normal.

Quelques points à noter:

• Vous devez avoir la version Python de Selenium RC installée pour que cela fonctionne, et vous devez avoir configuré Selenium correctement. Il ne s'agit également que d'un robot d'exploration de modèles. Vous pourriez devenir beaucoup plus fou et plus avancé avec les choses, mais je voulais juste montrer l'idée de base. Dans l'état actuel du code, vous ferez deux requêtes pour une URL donnée. Une demande est faite par Scrapy et l'autre par Selenium. Je suis sûr qu'il existe des moyens de contourner ce problème afin que vous puissiez simplement demander à Selenium de faire la seule et unique demande, mais je n'ai pas pris la peine de l'implémenter et en faisant deux demandes, vous pouvez également explorer la page avec Scrapy.

• C'est assez puissant car vous avez maintenant tout le DOM rendu disponible pour que vous puissiez l'explorer et vous pouvez toujours utiliser toutes les fonctionnalités d'exploration intéressantes de Scrapy. Cela ralentira bien sûr l'exploration, mais en fonction de combien vous avez besoin du DOM rendu, cela peut valoir la peine d'attendre.

  from scrapy.contrib.spiders import CrawlSpider, Rule
  from scrapy.contrib.linkextractors.sgml import SgmlLinkExtractor
  from scrapy.selector import HtmlXPathSelector
  from scrapy.http import Request
  
  from selenium import selenium
  
  class SeleniumSpider(CrawlSpider):
      name = "SeleniumSpider"
      start_urls = ["http://www.domain.com"]
  
      rules = (
          Rule(SgmlLinkExtractor(allow=('\.html', )), callback='parse_page',follow=True),
      )
  
      def __init__(self):
          CrawlSpider.__init__(self)
          self.verificationErrors = []
          self.selenium = selenium("localhost", 4444, "*chrome", "http://www.domain.com")
          self.selenium.start()
  
      def __del__(self):
          self.selenium.stop()
          print self.verificationErrors
          CrawlSpider.__del__(self)
  
      def parse_page(self, response):
          item = Item()
  
          hxs = HtmlXPathSelector(response)
          #Do some XPath selection with Scrapy
          hxs.select('//div').extract()
  
          sel = self.selenium
          sel.open(response.url)
  
          #Wait for javscript to load in Selenium
          time.sleep(2.5)
  
          #Do some crawling of javascript created content with Selenium
          sel.get_text("//div")
          yield item
  
  # Snippet imported from snippets.scrapy.org (which no longer works)
  # author: wynbennett
  # date  : Jun 21, 2011

Référence: http://snipplr.com/view/66998/

Une autre solution consisterait à implémenter un gestionnaire de téléchargement ou un middleware de gestionnaire de téléchargement. (voir la documentation de scrapy pour plus d'informations sur le middleware de téléchargement) Ce qui suit est un exemple de classe utilisant le sélénium avec le pilote Web phantomjs sans tête:

1) Définissez la classe dans le middlewares.pyscript.

from selenium import webdriver
from scrapy.http import HtmlResponse

class JsDownload(object):

    @check_spider_middleware
    def process_request(self, request, spider):
        driver = webdriver.PhantomJS(executable_path='D:\phantomjs.exe')
        driver.get(request.url)
        return HtmlResponse(request.url, encoding='utf-8', body=driver.page_source.encode('utf-8'))

2) Ajouter une JsDownload()classe à une variable DOWNLOADER_MIDDLEWAREdans settings.py:

DOWNLOADER_MIDDLEWARES = {'MyProj.middleware.MiddleWareModule.MiddleWareClass': 500}

3) Intégrez l' HTMLResponseintérieur your_spider.py. Le décodage du corps de la réponse vous donnera le résultat souhaité.

class Spider(CrawlSpider):
    # define unique name of spider
    name = "spider"

    start_urls = ["https://www.url.de"] 

    def parse(self, response):
        # initialize items
        item = CrawlerItem()

        # store data as items
        item["js_enabled"] = response.body.decode("utf-8") 

Addon facultatif:
je voulais la possibilité de dire à différents spiders quel middleware utiliser, j'ai donc implémenté ce wrapper:

def check_spider_middleware(method):
@functools.wraps(method)
def wrapper(self, request, spider):
    msg = '%%s %s middleware step' % (self.__class__.__name__,)
    if self.__class__ in spider.middleware:
        spider.log(msg % 'executing', level=log.DEBUG)
        return method(self, request, spider)
    else:
        spider.log(msg % 'skipping', level=log.DEBUG)
        return None

return wrapper

pour que le wrapper fonctionne, toutes les araignées doivent avoir au minimum:

middleware = set([])

pour inclure un middleware:

middleware = set([MyProj.middleware.ModuleName.ClassName])

Avantage:
Le principal avantage de l'implémenter de cette manière plutôt que dans l'araignée est que vous ne faites qu'une seule demande. Dans la solution d'AT, par exemple: le gestionnaire de téléchargement traite la demande puis transmet la réponse à l'araignée. L'araignée fait ensuite une toute nouvelle demande dans sa fonction parse_page - C'est deux demandes pour le même contenu.

J'utilisais un middleware de téléchargement personnalisé, mais j'en étais pas très satisfait, car je n'ai pas réussi à faire fonctionner le cache.

Une meilleure approche consistait à implémenter un gestionnaire de téléchargement personnalisé.

Il y a un exemple fonctionnel ici . Cela ressemble à ceci:

# encoding: utf-8
from __future__ import unicode_literals

from scrapy import signals
from scrapy.signalmanager import SignalManager
from scrapy.responsetypes import responsetypes
from scrapy.xlib.pydispatch import dispatcher
from selenium import webdriver
from six.moves import queue
from twisted.internet import defer, threads
from twisted.python.failure import Failure


class PhantomJSDownloadHandler(object):

    def __init__(self, settings):
        self.options = settings.get('PHANTOMJS_OPTIONS', {})

        max_run = settings.get('PHANTOMJS_MAXRUN', 10)
        self.sem = defer.DeferredSemaphore(max_run)
        self.queue = queue.LifoQueue(max_run)

        SignalManager(dispatcher.Any).connect(self._close, signal=signals.spider_closed)

    def download_request(self, request, spider):
        """use semaphore to guard a phantomjs pool"""
        return self.sem.run(self._wait_request, request, spider)

    def _wait_request(self, request, spider):
        try:
            driver = self.queue.get_nowait()
        except queue.Empty:
            driver = webdriver.PhantomJS(**self.options)

        driver.get(request.url)
        # ghostdriver won't response when switch window until page is loaded
        dfd = threads.deferToThread(lambda: driver.switch_to.window(driver.current_window_handle))
        dfd.addCallback(self._response, driver, spider)
        return dfd

    def _response(self, _, driver, spider):
        body = driver.execute_script("return document.documentElement.innerHTML")
        if body.startswith("<head></head>"):  # cannot access response header in Selenium
            body = driver.execute_script("return document.documentElement.textContent")
        url = driver.current_url
        respcls = responsetypes.from_args(url=url, body=body[:100].encode('utf8'))
        resp = respcls(url=url, body=body, encoding="utf-8")

        response_failed = getattr(spider, "response_failed", None)
        if response_failed and callable(response_failed) and response_failed(resp, driver):
            driver.close()
            return defer.fail(Failure())
        else:
            self.queue.put(driver)
            return defer.succeed(resp)

    def _close(self):
        while not self.queue.empty():
            driver = self.queue.get_nowait()
            driver.close()

Supposons que votre grattoir s'appelle "grattoir". Si vous mettez le code mentionné dans un fichier appelé handlers.py à la racine du dossier "scraper", vous pouvez ajouter à votre settings.py:

DOWNLOAD_HANDLERS = {
    'http': 'scraper.handlers.PhantomJSDownloadHandler',
    'https': 'scraper.handlers.PhantomJSDownloadHandler',
}

Et voilà, le DOM analysé par JS, avec cache scrapy, réessais, etc.

comment scrapy peut-il être utilisé pour gratter ces données dynamiques afin que je puisse les utiliser?

Je me demande pourquoi personne n'a publié la solution en utilisant uniquement Scrapy.

Consultez le billet de blog de l'équipe Scrapy SCRAPING INFINITE SCROLLING PAGES . L'exemple supprime http://spidyquotes.herokuapp.com/scroll site Web qui utilise le défilement infini.

L'idée est d' utiliser les outils de développement de votre navigateur et de remarquer les demandes AJAX, puis sur la base de ces informations, de créer les demandes de Scrapy .

import json
import scrapy


class SpidyQuotesSpider(scrapy.Spider):
    name = 'spidyquotes'
    quotes_base_url = 'http://spidyquotes.herokuapp.com/api/quotes?page=%s'
    start_urls = [quotes_base_url % 1]
    download_delay = 1.5

    def parse(self, response):
        data = json.loads(response.body)
        for item in data.get('quotes', []):
            yield {
                'text': item.get('text'),
                'author': item.get('author', {}).get('name'),
                'tags': item.get('tags'),
            }
        if data['has_next']:
            next_page = data['page'] + 1
            yield scrapy.Request(self.quotes_base_url % next_page)

oui, Scrapy peut supprimer des sites Web dynamiques, des sites Web rendus via javaScript.

Il existe deux approches pour gratter ce type de sites Web.

Première,

vous pouvez utiliser splashpour rendre le code Javascript, puis analyser le HTML rendu. vous pouvez trouver le document et le projet ici Scrapy splash, git

Seconde,

Comme tout le monde le dit, en surveillant le network calls, oui, vous pouvez trouver l'appel d'API qui récupère les données et simuler cet appel dans votre araignée tremblante pourrait vous aider à obtenir les données souhaitées.

Je gère la requête ajax en utilisant Selenium et le pilote Web Firefox. Ce n'est pas si rapide si vous avez besoin du robot en tant que démon, mais bien mieux que n'importe quelle solution manuelle. J'ai écrit un court tutoriel ici pour référence