Scrapy - Guia rápido

Scrapy é uma estrutura de rastreamento da web rápida e de código aberto escrita em Python, usada para extrair os dados da página da web com a ajuda de seletores baseados em XPath.

O Scrapy foi lançado pela primeira vez em 26 de junho de 2008 licenciado sob BSD, com um marco 1.0 sendo lançado em junho de 2015.

Por que usar o Scrapy?

  • É mais fácil construir e dimensionar grandes projetos de rastreamento.

  • Ele possui um mecanismo integrado chamado Seletores, para extrair os dados de sites.

  • Ele lida com as solicitações de forma assíncrona e é rápido.

  • Ele ajusta automaticamente a velocidade de rastreamento usando o mecanismo de aceleração automática .

  • Garante a acessibilidade do desenvolvedor.

Características do Scrapy

  • O Scrapy é um framework de rastreamento da web de código aberto e gratuito.

  • O Scrapy gera exportações de feed em formatos como JSON, CSV e XML.

  • O Scrapy tem suporte embutido para selecionar e extrair dados de fontes por XPath ou expressões CSS.

  • Scrapy baseado em crawler, permite extrair dados das páginas da web automaticamente.

Vantagens

  • O Scrapy é facilmente extensível, rápido e poderoso.

  • É um framework de aplicação multiplataforma (Windows, Linux, Mac OS e BSD).

  • Solicitações scrapy são agendadas e processadas de forma assíncrona.

  • O Scrapy vem com um serviço integrado chamado Scrapyd que permite fazer upload de projetos e controlar spiders usando o serviço web JSON.

  • É possível descartar qualquer site, embora esse site não tenha API para acesso a dados brutos.

Desvantagens

  • Scrapy é apenas para Python 2.7. +

  • A instalação é diferente para diferentes sistemas operacionais.

Neste capítulo, discutiremos como instalar e configurar o Scrapy. O Scrapy deve ser instalado com Python.

O Scrapy pode ser instalado usando pip. Para instalar, execute o seguinte comando -

pip install Scrapy

janelas

Note - Python 3 não é compatível com o sistema operacional Windows.

Step 1- Instale Python 2.7 a partir de Python

Defina as variáveis ​​ambientais adicionando os seguintes caminhos ao PATH -

C:\Python27\;C:\Python27\Scripts\;

Você pode verificar a versão do Python usando o seguinte comando -

python --version

Step 2- Instale o OpenSSL .

Adicione C: \ OpenSSL-Win32 \ bin em suas variáveis ​​ambientais.

Note - OpenSSL vem pré-instalado em todos os sistemas operacionais, exceto Windows.

Step 3- Instale os redistribuíveis Visual C ++ 2008 .

Step 4- Instale o pywin32 .

Step 5- Instale o pip para versões do Python anteriores a 2.7.9.

Você pode verificar a versão do pip usando o seguinte comando -

pip --version

Step 6 - Para instalar o scrapy, execute o seguinte comando -

pip install Scrapy

Anaconda

Se você tiver o anaconda ou miniconda instalado em sua máquina, execute o comando abaixo para instalar o Scrapy usando conda -

conda install -c scrapinghub scrapy

A empresa Scrapinghub oferece suporte a pacotes conda oficiais para Linux, Windows e OS X.

Note - É recomendado instalar o Scrapy usando o comando acima se você tiver problemas ao instalar via pip.

Ubuntu 9.10 ou superior

A versão mais recente do Python está pré-instalada no Ubuntu OS. Use os pacotes do Ubuntu aptgettable fornecidos pelo Scrapinghub. Para usar os pacotes -

Step 1 - Você precisa importar a chave GPG usada para assinar os pacotes Scrapy no chaveiro APT -

sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv 627220E7

Step 2 - Em seguida, use o seguinte comando para criar o arquivo /etc/apt/sources.list.d/scrapy.list -

echo 'deb http://archive.scrapy.org/ubuntu scrapy main' | sudo tee 
/etc/apt/sources.list.d/scrapy.list

Step 3 - Atualize a lista de pacotes e instale o scrapy -

sudo apt-get update && sudo apt-get install scrapy

Archlinux

Você pode instalar o Scrapy do pacote AUR Scrapy usando o seguinte comando -

yaourt -S scrapy

Mac OS X

Use o seguinte comando para instalar as ferramentas de linha de comando Xcode -

xcode-select --install

Em vez de usar o Python do sistema, instale uma nova versão atualizada que não entre em conflito com o resto do seu sistema.

Step 1- Instale homebrew .

Step 2 - Defina a variável PATH ambiental para especificar que os pacotes homebrew devem ser usados ​​antes dos pacotes do sistema -

echo "export PATH = /usr/local/bin:/usr/local/sbin:$PATH" >> ~/.bashrc

Step 3 - Para ter certeza de que as mudanças foram feitas, recarregue .bashrc usando o seguinte comando -

source ~/.bashrc

Step 4 - Em seguida, instale o Python usando o seguinte comando -

brew install python

Step 5 - Instale o Scrapy usando o seguinte comando -

pip install Scrapy

Descrição

A ferramenta de linha de comando Scrapy é usada para controlar o Scrapy, que geralmente é conhecido como 'Scrapy tool'. Inclui os comandos para vários objetos com um grupo de argumentos e opções.

Definições de configuração

O Scrapy encontrará definições de configuração no scrapy.cfgArquivo. A seguir estão alguns locais -

  • C: \ scrapy (pasta do projeto) \ scrapy.cfg no sistema

  • ~ / .config / scrapy.cfg ($ XDG_CONFIG_HOME) e ~ / .scrapy.cfg ($ HOME) para configurações globais

  • Você pode encontrar o scrapy.cfg dentro da raiz do projeto.

O Scrapy também pode ser configurado usando as seguintes variáveis ​​de ambiente -

  • SCRAPY_SETTINGS_MODULE
  • SCRAPY_PROJECT
  • SCRAPY_PYTHON_SHELL

Projeto Scrapy de Estrutura Padrão

A estrutura a seguir mostra a estrutura de arquivos padrão do projeto Scrapy.

scrapy.cfg                - Deploy the configuration file
project_name/             - Name of the project
   _init_.py
   items.py               - It is project's items file
   pipelines.py           - It is project's pipelines file
   settings.py            - It is project's settings file
   spiders                - It is the spiders directory
      _init_.py
      spider_name.py
      . . .

o scrapy.cfgfile é um diretório raiz do projeto, que inclui o nome do projeto com as configurações do projeto. Por exemplo -

[settings] 
default = [name of the project].settings  

[deploy] 
#url = http://localhost:6800/ 
project = [name of the project]

Usando a ferramenta Scrapy

A ferramenta Scrapy fornece alguns comandos de uso e disponíveis da seguinte forma -

Scrapy X.Y  - no active project 
Usage: 
   scrapy  [options] [arguments] 
Available commands: 
   crawl      It puts spider (handle the URL) to work for crawling data 
   fetch      It fetches the response from the given URL

Criando um Projeto

Você pode usar o seguinte comando para criar o projeto no Scrapy -

scrapy startproject project_name

Isso criará o projeto chamado project_namediretório. Em seguida, vá para o projeto recém-criado, usando o seguinte comando -

cd  project_name

Projetos de controle

Você pode controlar o projeto e gerenciá-los usando a ferramenta Scrapy e também criar o novo spider, usando o seguinte comando -

scrapy genspider mydomain mydomain.com

Os comandos como crawl, etc. devem ser usados ​​dentro do projeto Scrapy. Você saberá quais comandos devem ser executados dentro do projeto Scrapy na próxima seção.

O Scrapy contém alguns comandos integrados, que podem ser usados ​​em seu projeto. Para ver a lista de comandos disponíveis, use o seguinte comando -

scrapy -h

Quando você executa o seguinte comando, o Scrapy exibe a lista de comandos disponíveis conforme listado -

  • fetch - Ele busca a URL usando o downloader Scrapy.

  • runspider - É usado para executar o spider independente sem criar um projeto.

  • settings - Especifica o valor de configuração do projeto.

  • shell - É um módulo de raspagem interativo para o URL fornecido.

  • startproject - Cria um novo projeto Scrapy.

  • version - Exibe a versão Scrapy.

  • view - Ele busca a URL usando o downloader Scrapy e mostra o conteúdo em um navegador.

Você pode ter alguns comandos relacionados ao projeto, conforme listado -

  • crawl - É usado para rastrear dados usando o spider.

  • check - Verifica os itens retornados pelo comando rastreado.

  • list - Mostra a lista de spiders disponíveis presentes no projeto.

  • edit - Você pode editar as aranhas usando o editor.

  • parse - Ele analisa o URL fornecido com o spider.

  • bench - É usado para executar um teste de benchmark rápido (o Benchmark informa quantas páginas podem ser rastreadas por minuto pelo Scrapy).

Comandos de projeto personalizados

Você pode construir um comando de projeto personalizado com COMMANDS_MODULEconfiguração no projeto Scrapy. Inclui uma string vazia padrão na configuração. Você pode adicionar o seguinte comando personalizado -

COMMANDS_MODULE = 'mycmd.commands'

Os comandos Scrapy podem ser adicionados usando a seção scrapy.commands no arquivo setup.py mostrado a seguir -

from setuptools import setup, find_packages  

setup(name = 'scrapy-module_demo', 
   entry_points = { 
      'scrapy.commands': [ 
         'cmd_demo = my_module.commands:CmdDemo', 
      ], 
   }, 
)

O código acima adiciona cmd_demo comando no setup.py Arquivo.

Descrição

Spider é uma classe responsável por definir como seguir os links de um site e extrair as informações das páginas.

Os spiders padrão do Scrapy são os seguintes -

scrapy.Spider

É uma aranha da qual todas as outras aranhas devem herdar. Tem a seguinte classe -

class scrapy.spiders.Spider

A tabela a seguir mostra os campos da classe scrapy.Spider -

Sr. Não Campo e Descrição
1

name

É o nome da sua aranha.

2

allowed_domains

É uma lista de domínios nos quais o spider rasteja.

3

start_urls

É uma lista de URLs, que serão as raízes de rastreamentos posteriores, de onde o spider começará a rastrear.

4

custom_settings

Estas são as configurações, ao executar o spider, serão substituídas pela configuração de todo o projeto.

5

crawler

É um atributo vinculado ao objeto Crawler ao qual a instância do spider está associada.

6

settings

Estas são as configurações para executar uma aranha.

7

logger

É um logger Python usado para enviar mensagens de log.

8

from_crawler(crawler,*args,**kwargs)

É um método de classe, que cria sua aranha. Os parâmetros são -

  • crawler - Um rastreador ao qual a instância do spider será vinculada.

  • args(list)- Esses argumentos são passados ​​para o método _init_ () .

  • kwargs(dict)- Esses argumentos de palavra-chave são passados ​​para o método _init_ () .

9

start_requests()

Quando nenhum URL específico é especificado e o spider é aberto para descarte, o Scrapy chama o método start_requests () .

10

make_requests_from_url(url)

É um método usado para converter urls em solicitações.

11

parse(response)

Este método processa a resposta e retorna dados descartados seguindo mais URLs.

12

log(message[,level,component])

É um método que envia uma mensagem de log por meio do spiders logger.

13

closed(reason)

Este método é chamado quando o spider fecha.

Argumentos da Aranha

Argumentos de aranha são usados ​​para especificar URLs iniciais e são passados ​​usando o comando de rastreamento com -a opção, mostrada a seguir -

scrapy crawl first_scrapy -a group = accessories

O código a seguir demonstra como um spider recebe argumentos -

import scrapy 

class FirstSpider(scrapy.Spider): 
   name = "first" 
   
   def __init__(self, group = None, *args, **kwargs): 
      super(FirstSpider, self).__init__(*args, **kwargs) 
      self.start_urls = ["http://www.example.com/group/%s" % group]

Aranhas genéricas

Você pode usar spiders genéricos para criar uma subclasse de seus spiders. Seu objetivo é seguir todos os links do site com base em certas regras para extrair dados de todas as páginas.

Para os exemplos usados ​​nos seguintes spiders, vamos supor que temos um projeto com os seguintes campos -

import scrapy 
from scrapy.item import Item, Field 
  
class First_scrapyItem(scrapy.Item): 
   product_title = Field() 
   product_link = Field() 
   product_description = Field()

CrawlSpider

CrawlSpider define um conjunto de regras para seguir os links e scrap em mais de uma página. Tem a seguinte classe -

class scrapy.spiders.CrawlSpider

A seguir estão os atributos da classe CrawlSpider -

regras

É uma lista de objetos de regra que define como o rastreador segue o link.

A tabela a seguir mostra as regras da classe CrawlSpider -

Sr. Não Regra e descrição
1

LinkExtractor

Ele especifica como o spider segue os links e extrai os dados.

2

callback

Ele deve ser chamado depois que cada página for raspada.

3

follow

Ele especifica se deve continuar seguindo os links ou não.

parse_start_url (resposta)

Ele retorna o item ou o objeto de solicitação, permitindo analisar as respostas iniciais.

Note - Certifique-se de renomear a função de análise diferente de análise ao escrever as regras, porque a função de análise é usada por CrawlSpider para implementar sua lógica.

Vamos dar uma olhada no exemplo a seguir, onde o spider começa a rastrear a página inicial de demoexample.com, coletando todas as páginas, links e analisa com o método parse_items -

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

class DemoSpider(CrawlSpider):
   name = "demo"
   allowed_domains = ["www.demoexample.com"]
   start_urls = ["http://www.demoexample.com"]
      
   rules = ( 
      Rule(LinkExtractor(allow =(), restrict_xpaths = ("//div[@class = 'next']",)),
         callback = "parse_item", follow = True),
   )
   
   def parse_item(self, response):
      item = DemoItem()
      item["product_title"] = response.xpath("a/text()").extract()
      item["product_link"] = response.xpath("a/@href").extract()
      item["product_description"] = response.xpath("div[@class = 'desc']/text()").extract()
      return items

XMLFeedSpider

É a classe base para spiders que extraem feeds XML e iteram sobre nós. Tem a seguinte classe -

class scrapy.spiders.XMLFeedSpider

A tabela a seguir mostra os atributos de classe usados ​​para definir um iterador e um nome de tag -

Sr. Não Atributo e descrição
1

iterator

Ele define o iterador a ser usado. Pode ser iternodes, html ou xml . O padrão é iternodes .

2

itertag

É uma string com nome de nó para iterar.

3

namespaces

É definido por uma lista de tuplas (prefixo, uri) que registra automaticamente os espaços de nomes usando o método register_namespace () .

4

adapt_response(response)

Ele recebe a resposta e modifica o corpo da resposta assim que chega do middleware do spider, antes que o spider comece a analisá-lo.

5

parse_node(response,selector)

Ele recebe a resposta e um seletor quando chamado para cada nó que corresponde ao nome de tag fornecido.

Note - Seu spider não funcionará se você não substituir este método.

6

process_results(response,results)

Ele retorna uma lista de resultados e respostas retornadas pelo spider.

CSVFeedSpider

Ele itera em cada uma de suas linhas, recebe um arquivo CSV como resposta e chama o método parse_row () . Tem a seguinte classe -

class scrapy.spiders.CSVFeedSpider

A tabela a seguir mostra as opções que podem ser definidas em relação ao arquivo CSV -

Sr. Não Opção e descrição
1

delimiter

É uma string contendo uma vírgula (',') separador para cada campo.

2

quotechar

É uma string contendo aspas ('"') para cada campo.

3

headers

É uma lista de instruções de onde os campos podem ser extraídos.

4

parse_row(response,row)

Ele recebe uma resposta e cada linha junto com uma chave para o cabeçalho.

Exemplo CSVFeedSpider

from scrapy.spiders import CSVFeedSpider
from demoproject.items import DemoItem  

class DemoSpider(CSVFeedSpider): 
   name = "demo" 
   allowed_domains = ["www.demoexample.com"] 
   start_urls = ["http://www.demoexample.com/feed.csv"] 
   delimiter = ";" 
   quotechar = "'" 
   headers = ["product_title", "product_link", "product_description"]  
   
   def parse_row(self, response, row): 
      self.logger.info("This is row: %r", row)  
      item = DemoItem() 
      item["product_title"] = row["product_title"] 
      item["product_link"] = row["product_link"] 
      item["product_description"] = row["product_description"] 
      return item

SitemapSpider

O SitemapSpider, com a ajuda dos Sitemaps, rastreia um site localizando os URLs do robots.txt. Tem a seguinte classe -

class scrapy.spiders.SitemapSpider

A tabela a seguir mostra os campos de SitemapSpider -

Sr. Não Campo e Descrição
1

sitemap_urls

Uma lista de URLs que você deseja rastrear apontando para os sitemaps.

2

sitemap_rules

É uma lista de tuplas (regex, retorno de chamada), onde regex é uma expressão regular e o retorno de chamada é usado para processar URLs que correspondem a uma expressão regular.

3

sitemap_follow

É uma lista de regexes do mapa do site a seguir.

4

sitemap_alternate_links

Especifica links alternativos a serem seguidos para um único url.

Exemplo de SitemapSpider

O seguinte SitemapSpider processa todos os URLs -

from scrapy.spiders import SitemapSpider  

class DemoSpider(SitemapSpider): 
   urls = ["http://www.demoexample.com/sitemap.xml"]  
   
   def parse(self, response): 
      # You can scrap items here

O seguinte SitemapSpider processa alguns URLs com retorno de chamada -

from scrapy.spiders import SitemapSpider  

class DemoSpider(SitemapSpider): 
   urls = ["http://www.demoexample.com/sitemap.xml"] 
   
   rules = [ 
      ("/item/", "parse_item"), 
      ("/group/", "parse_group"), 
   ]  
   
   def parse_item(self, response): 
      # you can scrap item here  
   
   def parse_group(self, response): 
      # you can scrap group here

O código a seguir mostra os sitemaps no robots.txt cujo url tem /sitemap_company -

from scrapy.spiders import SitemapSpider

class DemoSpider(SitemapSpider): 
   urls = ["http://www.demoexample.com/robots.txt"] 
   rules = [ 
      ("/company/", "parse_company"), 
   ] 
   sitemap_follow = ["/sitemap_company"]  
   
   def parse_company(self, response): 
      # you can scrap company here

Você pode até combinar SitemapSpider com outros URLs, conforme mostrado no comando a seguir.

from scrapy.spiders import SitemapSpider  

class DemoSpider(SitemapSpider): 
   urls = ["http://www.demoexample.com/robots.txt"] 
   rules = [ 
      ("/company/", "parse_company"), 
   ]  
   
   other_urls = ["http://www.demoexample.com/contact-us"] 
   def start_requests(self): 
      requests = list(super(DemoSpider, self).start_requests()) 
      requests += [scrapy.Request(x, self.parse_other) for x in self.other_urls] 
      return requests 

   def parse_company(self, response): 
      # you can scrap company here... 

   def parse_other(self, response): 
      # you can scrap other here...

Descrição

Quando você está copiando as páginas da web, você precisa extrair uma certa parte do código-fonte HTML usando o mecanismo chamado selectors, obtido usando expressões XPath ou CSS. Os seletores são construídos sobrelxml biblioteca, que processa o XML e HTML em linguagem Python.

Use o seguinte snippet de código para definir diferentes conceitos de seletores -

<html>
   <head>
      <title>My Website</title>
   </head>
   
   <body>
      <span>Hello world!!!</span>
      <div class = 'links'>
         <a href = 'one.html'>Link 1<img src = 'image1.jpg'/></a>
         <a href = 'two.html'>Link 2<img src = 'image2.jpg'/></a>
         <a href = 'three.html'>Link 3<img src = 'image3.jpg'/></a>
      </div>
   </body>
</html>

Construindo Seletores

Você pode construir as instâncias da classe do seletor passando o text ou TextResponseobjeto. Com base no tipo de entrada fornecido, o seletor escolhe as seguintes regras -

from scrapy.selector import Selector 
from scrapy.http import HtmlResponse

Usando o código acima, você pode construir a partir do texto como -

Selector(text = body).xpath('//span/text()').extract()

Ele exibirá o resultado como -

[u'Hello world!!!']

Você pode construir a partir da resposta como -

response = HtmlResponse(url = 'http://mysite.com', body = body) 
Selector(response = response).xpath('//span/text()').extract()

Ele exibirá o resultado como -

[u'Hello world!!!']

Usando Seletores

Usando o trecho de código simples acima, você pode construir o XPath para selecionar o texto que é definido na tag de título conforme mostrado abaixo -

>>response.selector.xpath('//title/text()')

Agora, você pode extrair os dados textuais usando o .extract() método mostrado a seguir -

>>response.xpath('//title/text()').extract()

Ele produzirá o resultado como -

[u'My Website']

Você pode exibir o nome de todos os elementos mostrados a seguir -

>>response.xpath('//div[@class = "links"]/a/text()').extract()

Ele exibirá os elementos como -

Link 1
Link 2
Link 3

Se você deseja extrair o primeiro elemento, use o método .extract_first(), mostrado a seguir -

>>response.xpath('//div[@class = "links"]/a/text()').extract_first()

Ele exibirá o elemento como -

Link 1

Seletores de aninhamento

Usando o código acima, você pode aninhar os seletores para exibir o link da página e a fonte da imagem usando o .xpath() método, mostrado a seguir -

links = response.xpath('//a[contains(@href, "image")]') 

for index, link in enumerate(links): 
   args = (index, link.xpath('@href').extract(), link.xpath('img/@src').extract()) 
   print 'The link %d pointing to url %s and image %s' % args

Ele exibirá o resultado como -

Link 1 pointing to url [u'one.html'] and image [u'image1.jpg']
Link 2 pointing to url [u'two.html'] and image [u'image2.jpg']
Link 3 pointing to url [u'three.html'] and image [u'image3.jpg']

Seletores usando expressões regulares

Scrapy permite extrair os dados usando expressões regulares, que usam o .re()método. A partir do código HTML acima, iremos extrair os nomes das imagens mostrados a seguir -

>>response.xpath('//a[contains(@href, "image")]/text()').re(r'Name:\s*(.*)')

A linha acima exibe os nomes das imagens como -

[u'Link 1', 
u'Link 2', 
u'Link 3']

Usando XPaths Relativos

Quando você está trabalhando com XPaths, que começa com o /, os seletores aninhados e o XPath estão relacionados ao caminho absoluto do documento e não ao caminho relativo do seletor.

Se você deseja extrair o <p> elementos, então primeiro ganhe todos os elementos div -

>>mydiv = response.xpath('//div')

Em seguida, você pode extrair todos os 'p' elementos dentro, prefixando o XPath com um ponto como .//p como mostrado abaixo -

>>for p in mydiv.xpath('.//p').extract()

Usando extensões EXSLT

O EXSLT é uma comunidade que emite extensões para o XSLT (Extensible Stylesheet Language Transformations) que converte documentos XML em documentos XHTML. Você pode usar as extensões EXSLT com o namespace registrado nas expressões XPath, conforme mostrado na tabela a seguir -

Sr. Não Prefixo e uso Namespace
1

re

expressões regulares

http://exslt.org/regexp/index.html

2

set

manipulação de conjuntos

http://exslt.org/set/index.html

Você pode verificar o formato de código simples para extrair dados usando expressões regulares na seção anterior.

Existem algumas dicas XPath, que são úteis ao usar XPath com seletores Scrapy. Para mais informações, clique neste link .

Descrição

O processo Scrapy pode ser usado para extrair os dados de fontes, como páginas da web, usando spiders. Scrapy usaItem classe para produzir a saída cujos objetos são usados ​​para reunir os dados extraídos.

Declarando Itens

Você pode declarar os itens usando a sintaxe de definição de classe junto com os objetos de campo mostrados a seguir -

import scrapy 
class MyProducts(scrapy.Item): 
   productName = Field() 
   productLink = Field() 
   imageURL = Field() 
   price = Field() 
   size = Field()

Campos do Item

Os campos do item são usados ​​para exibir os metadados de cada campo. Como não há limitação de valores nos objetos de campo, as chaves de metadados acessíveis não contêm nenhuma lista de referência dos metadados. Os objetos de campo são usados ​​para especificar todos os metadados de campo e você pode especificar qualquer outra chave de campo de acordo com sua necessidade no projeto. Os objetos de campo podem ser acessados ​​usando o atributo Item.fields.

Trabalhando com Itens

Existem algumas funções comuns que podem ser definidas quando você está trabalhando com os itens. Para mais informações, clique neste link .

Estendendo Itens

Os itens podem ser estendidos declarando a subclasse do item original. Por exemplo -

class MyProductDetails(Product): 
   original_rate = scrapy.Field(serializer = str) 
   discount_rate = scrapy.Field()

Você pode usar os metadados de campo existentes para estender os metadados de campo adicionando mais valores ou alterando os valores existentes, conforme mostrado no código a seguir -

class MyProductPackage(Product): 
   name = scrapy.Field(Product.fields['name'], serializer = serializer_demo)

Objetos de Item

Os objetos de item podem ser especificados usando a seguinte classe que fornece o novo item inicializado a partir do argumento fornecido -

class scrapy.item.Item([arg])

O Item fornece uma cópia do construtor e fornece um atributo extra que é fornecido pelos itens nos campos.

Objetos de Campo

Os objetos de campo podem ser especificados usando a seguinte classe em que a classe Field não emite o processo ou atributos adicionais -

class scrapy.item.Field([arg])

Descrição

Os carregadores de itens fornecem uma maneira conveniente de preencher os itens que são retirados dos sites.

Declaração de carregadores de itens

A declaração de carregadores de itens é como itens.

Por exemplo -

from scrapy.loader import ItemLoader 
from scrapy.loader.processors import TakeFirst, MapCompose, Join  

class DemoLoader(ItemLoader):  
   default_output_processor = TakeFirst()  
   title_in = MapCompose(unicode.title) 
   title_out = Join()  
   size_in = MapCompose(unicode.strip)  
   # you can continue scraping here

No código acima, você pode ver que os processadores de entrada são declarados usando _in sufixo e processadores de saída são declarados usando _out sufixo.

o ItemLoader.default_input_processor e ItemLoader.default_output_processor atributos são usados ​​para declarar processadores de entrada / saída padrão.

Usando carregadores de itens para preencher itens

Para usar o carregador de itens, primeiro instancie com o objeto do tipo dict ou sem um onde o item use a classe de item especificada em ItemLoader.default_item_class atributo.

  • Você pode usar seletores para coletar valores no carregador de itens.

  • Você pode adicionar mais valores no mesmo campo de item, onde o carregador de itens usará um manipulador apropriado para adicionar esses valores.

O código a seguir demonstra como os itens são preenchidos usando carregadores de itens -

from scrapy.loader import ItemLoader 
from demoproject.items import Demo  

def parse(self, response): 
   l = ItemLoader(item = Product(), response = response)
   l.add_xpath("title", "//div[@class = 'product_title']")
   l.add_xpath("title", "//div[@class = 'product_name']")
   l.add_xpath("desc", "//div[@class = 'desc']")
   l.add_css("size", "div#size]")
   l.add_value("last_updated", "yesterday")
   return l.load_item()

Conforme mostrado acima, existem dois XPaths diferentes dos quais o title campo é extraído usando add_xpath() método -

1. //div[@class = "product_title"] 
2. //div[@class = "product_name"]

Depois disso, uma solicitação semelhante é usada para desccampo. Os dados de tamanho são extraídos usandoadd_css() método e last_updated é preenchido com um valor "ontem" usando add_value() método.

Assim que todos os dados forem coletados, ligue ItemLoader.load_item() método que retorna os itens preenchidos com dados extraídos usando add_xpath(), add_css() e add_value() métodos.

Processadores de entrada e saída

Cada campo de um carregador de itens contém um processador de entrada e um processador de saída.

  • Quando os dados são extraídos, o processador de entrada os processa e seu resultado é armazenado no ItemLoader.

  • Em seguida, após coletar os dados, chame o método ItemLoader.load_item () para obter o objeto Item preenchido.

  • Finalmente, você pode atribuir o resultado do processador de saída ao item.

O código a seguir demonstra como chamar processadores de entrada e saída para um campo específico -

l = ItemLoader(Product(), some_selector)
l.add_xpath("title", xpath1) # [1]
l.add_xpath("title", xpath2) # [2]
l.add_css("title", css)      # [3]
l.add_value("title", "demo") # [4]
return l.load_item()         # [5]

Line 1 - Os dados do título são extraídos de xpath1 e passados ​​pelo processador de entrada e seu resultado é coletado e armazenado no ItemLoader.

Line 2 - Da mesma forma, o título é extraído de xpath2 e passado pelo mesmo processador de entrada e seu resultado é adicionado aos dados coletados para [1].

Line 3 - O título é extraído do seletor css e passado pelo mesmo processador de entrada e o resultado é adicionado aos dados coletados para [1] e [2].

Line 4 - Em seguida, o valor "demo" é atribuído e passado pelos processadores de entrada.

Line 5 - Por fim, os dados são coletados internamente de todos os campos e passados ​​para o processador de saída e o valor final é atribuído ao Item.

Declaração de processadores de entrada e saída

Os processadores de entrada e saída são declarados na definição ItemLoader. Além disso, eles também podem ser especificados noItem Field metadados.

Por exemplo -

import scrapy 
from scrapy.loader.processors import Join, MapCompose, TakeFirst 
from w3lib.html import remove_tags  

def filter_size(value): 
   if value.isdigit(): 
      return value  

class Item(scrapy.Item): 
   name = scrapy.Field( 
      input_processor = MapCompose(remove_tags), 
      output_processor = Join(), 
   )
   size = scrapy.Field( 
      input_processor = MapCompose(remove_tags, filter_price), 
      output_processor = TakeFirst(), 
   ) 

>>> from scrapy.loader import ItemLoader 
>>> il = ItemLoader(item = Product()) 
>>> il.add_value('title', [u'Hello', u'<strong>world</strong>']) 
>>> il.add_value('size', [u'<span>100 kg</span>']) 
>>> il.load_item()

Ele exibe uma saída como -

{'title': u'Hello world', 'size': u'100 kg'}

Contexto do carregador de itens

O Item Loader Context é um dicionário de valores-chave arbitrários compartilhados entre os processadores de entrada e saída.

Por exemplo, suponha que você tenha uma função parse_length -

def parse_length(text, loader_context): 
   unit = loader_context.get('unit', 'cm') 
   
   # You can write parsing code of length here  
   return parsed_length

Ao receber argumentos loader_context, ele informa ao carregador de itens que pode receber o contexto do carregador de itens. Existem várias maneiras de alterar o valor do contexto do carregador de itens -

  • Modificar o contexto atual do carregador de item ativo -

loader = ItemLoader (product)
loader.context ["unit"] = "mm"
  • Na instanciação do carregador de itens -

loader = ItemLoader(product, unit = "mm")
  • Declaração On Item Loader para processadores de entrada / saída que instancia com o contexto Item Loader -

class ProductLoader(ItemLoader):
   length_out = MapCompose(parse_length, unit = "mm")

Objetos ItemLoader

É um objeto que retorna um novo carregador de item para preencher o item fornecido. Tem a seguinte classe -

class scrapy.loader.ItemLoader([item, selector, response, ]**kwargs)

A tabela a seguir mostra os parâmetros dos objetos ItemLoader -

Sr. Não Parâmetro e Descrição
1

item

É o item a preencher chamando add_xpath (), add_css () ou add_value ().

2

selector

Ele é usado para extrair dados de sites.

3

response

É usado para construir o seletor usando default_selector_class.

A tabela a seguir mostra os métodos de objetos ItemLoader -

Sr. Não Método e Descrição Exemplo
1

get_value(value, *processors, **kwargs)

Por um determinado processador e argumentos de palavra-chave, o valor é processado pelo método get_value ().

>>> from scrapy.loader.processors import TakeFirst
>>> loader.get_value(u'title: demoweb', TakeFirst(), 
unicode.upper, re = 'title: (.+)')
'DEMOWEB`
2

add_value(field_name, value, *processors, **kwargs)

Ele processa o valor e adiciona ao campo onde é passado pela primeira vez por get_value, fornecendo a processadores e argumentos de palavra-chave antes de passar pelo processador de entrada de campo.

loader.add_value('title', u'DVD')
loader.add_value('colors', [u'black', u'white'])
loader.add_value('length', u'80')
loader.add_value('price', u'2500')
3

replace_value(field_name, value, *processors, **kwargs)

Ele substitui os dados coletados por um novo valor.

loader.replace_value('title', u'DVD')
loader.replace_value('colors', [u'black', 
u'white'])
loader.replace_value('length', u'80')
loader.replace_value('price', u'2500')
4

get_xpath(xpath, *processors, **kwargs)

Ele é usado para extrair cadeias de caracteres Unicode fornecendo processadores e argumentos de palavra-chave ao receber XPath .

# HTML code: <div class = "item-name">DVD</div>
loader.get_xpath("//div[@class = 
'item-name']")

# HTML code: <div id = "length">the length is 
45cm</div>
loader.get_xpath("//div[@id = 'length']", TakeFirst(), 
re = "the length is (.*)")
5

add_xpath(field_name, xpath, *processors, **kwargs)

Ele recebe XPath para o campo que extrai strings Unicode.

# HTML code: <div class = "item-name">DVD</div>
loader.add_xpath('name', '//div
[@class = "item-name"]')

# HTML code: <div id = "length">the length is 
45cm</div>
loader.add_xpath('length', '//div[@id = "length"]',
 re = 'the length is (.*)')
6

replace_xpath(field_name, xpath, *processors, **kwargs)

Ele substitui os dados coletados usando XPath de sites.

# HTML code: <div class = "item-name">DVD</div>
loader.replace_xpath('name', '
//div[@class = "item-name"]')

# HTML code: <div id = "length">the length is
 45cm</div>
loader.replace_xpath('length', '
//div[@id = "length"]', re = 'the length is (.*)')
7

get_css(css, *processors, **kwargs)

Ele recebe o seletor CSS usado para extrair as strings Unicode.

loader.get_css("div.item-name")
loader.get_css("div#length", TakeFirst(), 
re = "the length is (.*)")
8

add_css(field_name, css, *processors, **kwargs)

É semelhante ao método add_value () com uma diferença que adiciona o seletor CSS ao campo.

loader.add_css('name', 'div.item-name')
loader.add_css('length', 'div#length', 
re = 'the length is (.*)')
9

replace_css(field_name, css, *processors, **kwargs)

Ele substitui os dados extraídos usando o seletor CSS.

loader.replace_css('name', 'div.item-name')
loader.replace_css('length', 'div#length',
 re = 'the length is (.*)')
10

load_item()

Quando os dados são coletados, esse método preenche o item com os dados coletados e os retorna.

def parse(self, response):
l = ItemLoader(item = Product(), 
response = response)
l.add_xpath('title', '//
div[@class = "product_title"]')
loader.load_item()
11

nested_xpath(xpath)

Ele é usado para criar carregadores aninhados com um seletor XPath.

loader = ItemLoader(item = Item())
loader.add_xpath('social', '
a[@class = "social"]/@href')
loader.add_xpath('email', '
a[@class = "email"]/@href')
12

nested_css(css)

É usado para criar carregadores aninhados com um seletor CSS.

loader = ItemLoader(item = Item())
loader.add_css('social', 'a[@class = "social"]/@href')
loader.add_css('email', 'a[@class = "email"]/@href')

A tabela a seguir mostra os atributos dos objetos ItemLoader -

Sr. Não Atributo e descrição
1

item

É um objeto no qual o carregador de itens executa a análise.

2

context

É o contexto atual do carregador de itens que está ativo.

3

default_item_class

É usado para representar os itens, se não for fornecido no construtor.

4

default_input_processor

Os campos que não especificam processador de entrada são os únicos para os quais default_input_processors são usados.

5

default_output_processor

Os campos que não especificam o processador de saída são os únicos para os quais default_output_processors são usados.

6

default_selector_class

É uma classe usada para construir o seletor, se não for fornecido no construtor.

7

selector

É um objeto que pode ser usado para extrair os dados dos sites.

Carregadores aninhados

Ele é usado para criar carregadores aninhados enquanto analisa os valores da subseção de um documento. Se você não criar carregadores aninhados, precisará especificar XPath ou CSS completo para cada valor que deseja extrair.

Por exemplo, suponha que os dados estejam sendo extraídos de uma página de cabeçalho -

<header>
   <a class = "social" href = "http://facebook.com/whatever">facebook</a>
   <a class = "social" href = "http://twitter.com/whatever">twitter</a>
   <a class = "email" href = "mailto:[email protected]">send mail</a>
</header>

Em seguida, você pode criar um carregador aninhado com seletor de cabeçalho, adicionando valores relacionados ao cabeçalho -

loader = ItemLoader(item = Item())
header_loader = loader.nested_xpath('//header')
header_loader.add_xpath('social', 'a[@class = "social"]/@href')
header_loader.add_xpath('email', 'a[@class = "email"]/@href')
loader.load_item()

Reutilizar e ampliar carregadores de itens

Os carregadores de itens são projetados para aliviar a manutenção que se torna um problema fundamental quando o seu projeto adquire mais spiders.

Por exemplo, suponha que um site tenha o nome do produto entre três traços (por exemplo, --DVD ---). Você pode remover esses travessões reutilizando o carregador de item de produto padrão, se não quiser nos nomes dos produtos finais, conforme mostrado no código a seguir -

from scrapy.loader.processors import MapCompose 
from demoproject.ItemLoaders import DemoLoader  

def strip_dashes(x): 
   return x.strip('-')  

class SiteSpecificLoader(DemoLoader): 
   title_in = MapCompose(strip_dashes, DemoLoader.title_in)

Processadores integrados disponíveis

A seguir estão alguns dos processadores embutidos comumente usados ​​-

classe scrapy.loader.processors.Identity

Ele retorna o valor original sem alterá-lo. Por exemplo -

>>> from scrapy.loader.processors import Identity
>>> proc = Identity()
>>> proc(['a', 'b', 'c'])
['a', 'b', 'c']

classe scrapy.loader.processors.TakeFirst

Ele retorna o primeiro valor não nulo / não vazio da lista de valores recebidos. Por exemplo -

>>> from scrapy.loader.processors import TakeFirst
>>> proc = TakeFirst()
>>> proc(['', 'a', 'b', 'c'])
'a'

classe scrapy.loader.processors.Join (separator = u '')

Ele retorna o valor anexado ao separador. O separador padrão é u '' e é equivalente à funçãou' '.join. Por exemplo -

>>> from scrapy.loader.processors import Join
>>> proc = Join()
>>> proc(['a', 'b', 'c'])
u'a b c'
>>> proc = Join('<br>')
>>> proc(['a', 'b', 'c'])
u'a<br>b<br>c'

classe scrapy.loader.processors.Compose (* funções, ** default_loader_context)

É definido por um processador onde cada um de seus valores de entrada é passado para a primeira função, e o resultado dessa função é passado para a segunda função e assim por diante, até que a função ast retorne o valor final como saída.

Por exemplo -

>>> from scrapy.loader.processors import Compose
>>> proc = Compose(lambda v: v[0], str.upper)
>>> proc(['python', 'scrapy'])
'PYTHON'

classe scrapy.loader.processors.MapCompose (* funções, ** default_loader_context)

É um processador onde o valor de entrada é iterado e a primeira função é aplicada a cada elemento. Em seguida, o resultado dessas chamadas de função são concatenados para construir um novo iterável que é então aplicado à segunda função e assim por diante, até a última função.

Por exemplo -

>>> def filter_scrapy(x): 
   return None if x == 'scrapy' else x  

>>> from scrapy.loader.processors import MapCompose 
>>> proc = MapCompose(filter_scrapy, unicode.upper) 
>>> proc([u'hi', u'everyone', u'im', u'pythonscrapy']) 
[u'HI, u'IM', u'PYTHONSCRAPY']

classe scrapy.loader.processors.SelectJmes (json_path)

Esta classe consulta o valor usando o caminho json fornecido e retorna a saída.

Por exemplo -

>>> from scrapy.loader.processors import SelectJmes, Compose, MapCompose
>>> proc = SelectJmes("hello")
>>> proc({'hello': 'scrapy'})
'scrapy'
>>> proc({'hello': {'scrapy': 'world'}})
{'scrapy': 'world'}

A seguir está o código, que consulta o valor importando json -

>>> import json
>>> proc_single_json_str = Compose(json.loads, SelectJmes("hello"))
>>> proc_single_json_str('{"hello": "scrapy"}')
u'scrapy'
>>> proc_json_list = Compose(json.loads, MapCompose(SelectJmes('hello')))
>>> proc_json_list('[{"hello":"scrapy"}, {"world":"env"}]')
[u'scrapy']

Descrição

Scrapy shell pode ser usado para descartar os dados com código livre de erros, sem o uso do spider. O principal objetivo do Scrapy shell é testar o código extraído, XPath ou expressões CSS. Também ajuda a especificar as páginas da web das quais você está copiando os dados.

Configurando o Shell

O shell pode ser configurado instalando o console IPython (usado para computação interativa), que é um poderoso shell interativo que fornece preenchimento automático, saída colorida, etc.

Se você está trabalhando na plataforma Unix, é melhor instalar o IPython. Você também pode usar bpython , se o IPython estiver inacessível.

Você pode configurar o shell definindo a variável de ambiente chamada SCRAPY_PYTHON_SHELL ou definindo o arquivo scrapy.cfg da seguinte maneira -

[settings]
shell = bpython

Lançando o Shell

O Scrapy Shell pode ser iniciado usando o seguinte comando -

scrapy shell <url>

O url especifica o URL para o qual os dados precisam ser copiados.

Usando o Shell

O shell fornece alguns atalhos adicionais e objetos Scrapy, conforme descrito na tabela a seguir -

Atalhos Disponíveis

Shell fornece os seguintes atalhos disponíveis no projeto -

Sr. Não Atalho e descrição
1

shelp()

Ele fornece os objetos e atalhos disponíveis com a opção de ajuda.

2

fetch(request_or_url)

Ele coleta a resposta da solicitação ou URL e os objetos associados são atualizados corretamente.

3

view(response)

Você pode visualizar a resposta para a solicitação fornecida no navegador local para observação e para exibir o link externo corretamente, ele anexa uma tag base ao corpo da resposta.

Objetos Scrapy Disponíveis

A Shell fornece os seguintes objetos Scrapy disponíveis no projeto -

Sr. Não Objeto e descrição
1

crawler

Ele especifica o objeto rastreador atual.

2

spider

Se não houver spider para o URL presente, ele tratará o URL ou o objeto spider definindo o novo spider.

3

request

Ele especifica o objeto de solicitação da última página coletada.

4

response

Ele especifica o objeto de resposta para a última página coletada.

5

settings

Ele fornece as configurações atuais do Scrapy.

Exemplo de Sessão Shell

Vamos tentar extrair o site scrapy.org e, em seguida, começar a remover os dados do reddit.com conforme descrito.

Antes de prosseguir, primeiro vamos lançar o shell conforme mostrado no seguinte comando -

scrapy shell 'http://scrapy.org' --nolog

O Scrapy exibirá os objetos disponíveis ao usar o URL acima -

[s] Available Scrapy objects:
[s]   crawler    <scrapy.crawler.Crawler object at 0x1e16b50>
[s]   item       {}
[s]   request    <GET http://scrapy.org >
[s]   response   <200 http://scrapy.org >
[s]   settings   <scrapy.settings.Settings object at 0x2bfd650>
[s]   spider     <Spider 'default' at 0x20c6f50>
[s] Useful shortcuts:
[s]   shelp()           Provides available objects and shortcuts with help option
[s]   fetch(req_or_url) Collects the response from the request or URL and associated 
objects will get update
[s]   view(response)    View the response for the given request

Em seguida, comece com o trabalho de objetos, mostrado a seguir -

>> response.xpath('//title/text()').extract_first() 
u'Scrapy | A Fast and Powerful Scraping and Web Crawling Framework'  
>> fetch("http://reddit.com") 
[s] Available Scrapy objects: 
[s]   crawler     
[s]   item       {} 
[s]   request     
[s]   response   <200 https://www.reddit.com/> 
[s]   settings    
[s]   spider      
[s] Useful shortcuts: 
[s]   shelp()           Shell help (print this help) 
[s]   fetch(req_or_url) Fetch request (or URL) and update local objects 
[s]   view(response)    View response in a browser  
>> response.xpath('//title/text()').extract() 
[u'reddit: the front page of the internet']  
>> request = request.replace(method="POST")  
>> fetch(request) 
[s] Available Scrapy objects: 
[s]   crawler     
...

Invocando o Shell de Spiders para Inspecionar Respostas

Você pode inspecionar as respostas que são processadas a partir do spider, apenas se estiver esperando obter essa resposta.

Por exemplo -

import scrapy 

class SpiderDemo(scrapy.Spider): 
   name = "spiderdemo" 
   start_urls = [ 
      "http://mysite.com", 
      "http://mysite1.org", 
      "http://mysite2.net", 
   ]  
   
   def parse(self, response): 
      # You can inspect one specific response 
      if ".net" in response.url: 
         from scrapy.shell import inspect_response 
         inspect_response(response, self)

Conforme mostrado no código acima, você pode invocar o shell de spiders para inspecionar as respostas usando a seguinte função -

scrapy.shell.inspect_response

Agora execute o spider e você obterá a seguinte tela -

2016-02-08 18:15:20-0400 [scrapy] DEBUG: Crawled (200)  (referer: None) 
2016-02-08 18:15:20-0400 [scrapy] DEBUG: Crawled (200)  (referer: None) 
2016-02-08 18:15:20-0400 [scrapy] DEBUG: Crawled (200)  (referer: None) 
[s] Available Scrapy objects: 
[s]   crawler     
...  
>> response.url 
'http://mysite2.org'

Você pode examinar se o código extraído está funcionando usando o seguinte código -

>> response.xpath('//div[@class = "val"]')

Ele exibe a saída como

[]

A linha acima exibiu apenas uma saída em branco. Agora você pode invocar o shell para inspecionar a resposta da seguinte maneira -

>> view(response)

Ele exibe a resposta como

True

Descrição

Item Pipelineé um método onde os itens descartados são processados. Quando um item é enviado para o Pipeline de itens, ele é raspado por um spider e processado usando vários componentes, que são executados sequencialmente.

Sempre que um item é recebido, ele decide uma das seguintes ações -

  • Continue processando o item.
  • Solte-o do pipeline.
  • Pare de processar o item.

Os pipelines de itens são geralmente usados ​​para os seguintes fins -

  • Armazenando itens raspados no banco de dados.
  • Se o item recebido for repetido, ele descartará o item repetido.
  • Ele verificará se o item está com campos direcionados.
  • Limpando dados HTML.

Sintaxe

Você pode escrever o Item Pipeline usando o seguinte método -

process_item(self, item, spider)

O método acima contém os seguintes parâmetros -

  • Item (objeto de item ou dicionário) - Especifica o item raspado.
  • aranha (objeto aranha) - A aranha que raspou o item.

Você pode usar métodos adicionais fornecidos na tabela a seguir -

Sr. Não Método e Descrição Parâmetros
1

open_spider(self, spider)

É selecionado quando o spider é aberto.

aranha (objeto aranha) - Refere-se à aranha que foi aberta.

2

close_spider(self, spider)

É selecionado quando o spider está fechado.

aranha (objeto aranha) - Refere-se à aranha que foi fechada.

3

from_crawler(cls, crawler)

Com a ajuda do rastreador, o pipeline pode acessar os componentes principais, como sinais e configurações do Scrapy.

crawler (objeto Crawler) - Refere-se ao crawler que usa este pipeline.

Exemplo

A seguir estão os exemplos de pipeline de itens usados ​​em diferentes conceitos.

Descartando itens sem etiqueta

No código a seguir, o pipeline equilibra o atributo (preço) para os itens que não incluem IVA (atributo excludes_vat) e ignora os itens que não têm etiqueta de preço -

from Scrapy.exceptions import DropItem  
class PricePipeline(object): 
   vat = 2.25 

   def process_item(self, item, spider): 
      if item['price']: 
         if item['excludes_vat']: 
            item['price'] = item['price'] * self.vat 
            return item 
         else: 
            raise DropItem("Missing price in %s" % item)

Gravando itens em um arquivo JSON

O código a seguir irá armazenar todos os itens raspados de todas as aranhas em um único items.jlarquivo, que contém um item por linha em um formulário serializado no formato JSON. oJsonWriterPipeline classe é usada no código para mostrar como escrever pipeline de item -

import json  

class JsonWriterPipeline(object): 
   def __init__(self): 
      self.file = open('items.jl', 'wb') 

   def process_item(self, item, spider): 
      line = json.dumps(dict(item)) + "\n" 
      self.file.write(line) 
      return item

Gravando itens no MongoDB

Você pode especificar o endereço do MongoDB e o nome do banco de dados nas configurações do Scrapy e a coleção do MongoDB pode ser nomeada de acordo com a classe do item. O código a seguir descreve como usarfrom_crawler() método para coletar os recursos adequadamente -

import pymongo  

class MongoPipeline(object):  
   collection_name = 'Scrapy_list' 

   def __init__(self, mongo_uri, mongo_db): 
      self.mongo_uri = mongo_uri 
      self.mongo_db = mongo_db 

   @classmethod 
   def from_crawler(cls, crawler): 
      return cls( 
         mongo_uri = crawler.settings.get('MONGO_URI'), 
         mongo_db = crawler.settings.get('MONGO_DB', 'lists') 
      ) 
  
   def open_spider(self, spider): 
      self.client = pymongo.MongoClient(self.mongo_uri) 
      self.db = self.client[self.mongo_db] 

   def close_spider(self, spider): 
      self.client.close() 

   def process_item(self, item, spider): 
      self.db[self.collection_name].insert(dict(item)) 
      return item

Filtros de duplicação

Um filtro verificará os itens repetidos e descartará os itens já processados. No código a seguir, usamos um id único para nossos itens, mas o spider retorna muitos itens com o mesmo id -

from scrapy.exceptions import DropItem  

class DuplicatesPipeline(object):  
   def __init__(self): 
      self.ids_seen = set() 

   def process_item(self, item, spider): 
      if item['id'] in self.ids_seen: 
         raise DropItem("Repeated items found: %s" % item) 
      else: 
         self.ids_seen.add(item['id']) 
         return item

Ativando um Pipeline de Item

Você pode ativar um componente Item Pipeline adicionando sua classe à configuração ITEM_PIPELINES , conforme mostrado no código a seguir. Você pode atribuir valores inteiros às classes na ordem em que são executadas (a ordem pode ser de menor valor para classes de maior valor) e os valores estarão na faixa de 0-1000.

ITEM_PIPELINES = {
   'myproject.pipelines.PricePipeline': 100,
   'myproject.pipelines.JsonWriterPipeline': 600,
}

Descrição

As exportações de feed são um método de armazenar os dados extraídos dos sites, que está gerando um "export file".

Formatos de serialização

Usando vários formatos de serialização e back-ends de armazenamento, as Exportações de feed usam exportadores de itens e geram um feed com itens descartados.

A seguinte tabela mostra os formatos suportados -

Sr. Não Formato e descrição
1

JSON

FEED_FORMAT é json

O exportador usado é a classe scrapy.exporters.JsonItemExporter

2

JSON lines

FEED_FROMAT é jsonlines

O exportador usado é a classe scrapy.exporters.JsonLinesItemExporter

3

CSV

FEED_FORMAT é CSV

O exportador usado é a classe scrapy.exporters.CsvItemExporter

4

XML

FEED_FORMAT é xml

O exportador usado é a classe scrapy.exporters.XmlItemExporter

Usando FEED_EXPORTERS configurações, os formatos suportados também podem ser estendidos -

Sr. Não Formato e descrição
1

Pickle

FEED_FORMAT é pickel

O exportador usado é a classe scrapy.exporters.PickleItemExporter

2

Marshal

FEED_FORMAT é marechal

O exportador usado é a classe scrapy.exporters.MarshalItemExporter

Back-ends de armazenamento

O back-end de armazenamento define onde armazenar o feed usando URI.

A tabela a seguir mostra os back-ends de armazenamento compatíveis -

Sr. Não Back-end de armazenamento e descrição
1

Local filesystem

O esquema de URI é um arquivo e é usado para armazenar os feeds.

2

FTP

O esquema de URI é ftp e é usado para armazenar os feeds.

3

S3

O esquema de URI é S3 e os feeds são armazenados no Amazon S3. Bibliotecas externas botocore ou boto são necessárias.

4

Standard output

O esquema de URI é stdout e os feeds são armazenados na saída padrão.

Parâmetros de URI de armazenamento

A seguir estão os parâmetros de URL de armazenamento, que são substituídos enquanto o feed está sendo criado -

  • % (time) s: este parâmetro é substituído por um carimbo de data / hora.
  • % (name) s: Este parâmetro é substituído pelo nome da aranha.

Configurações

A tabela a seguir mostra as configurações usando as quais as exportações de feed podem ser definidas -

Sr. Não Configuração e descrição
1

FEED_URI

É o URI do feed de exportação usado para habilitar as exportações de feed.

2

FEED_FORMAT

É um formato de serialização usado para o feed.

3

FEED_EXPORT_FIELDS

É usado para definir campos que precisam ser exportados.

4

FEED_STORE_EMPTY

Ele define se os feeds devem ser exportados sem itens.

5

FEED_STORAGES

É um dicionário com back-ends de armazenamento de feed adicionais.

6

FEED_STORAGES_BASE

É um dicionário com back-ends de armazenamento de feed integrados.

7

FEED_EXPORTERS

É um dicionário com exportadores de alimentos adicionais.

8

FEED_EXPORTERS_BASE

É um dicionário com exportadores de ração integrados.

Descrição

O Scrapy pode rastrear sites usando o Request e Responseobjetos. Os objetos de solicitação passam pelo sistema, usam os spiders para executar a solicitação e retornam à solicitação quando ela retorna um objeto de resposta.

Objetos de Solicitação

O objeto de solicitação é uma solicitação HTTP que gera uma resposta. Tem a seguinte classe -

class scrapy.http.Request(url[, callback, method = 'GET', headers, body, cookies, meta,
   encoding = 'utf-8', priority = 0, dont_filter = False, errback])

A tabela a seguir mostra os parâmetros dos objetos Request -

Sr. Não Parâmetro e Descrição
1

url

É uma string que especifica a solicitação de URL.

2

callback

É uma função chamável que usa a resposta do pedido como primeiro parâmetro.

3

method

É uma string que especifica a solicitação do método HTTP.

4

headers

É um dicionário com cabeçalhos de solicitação.

5

body

É uma string ou Unicode que possui um corpo de solicitação.

6

cookies

É uma lista contendo cookies de solicitação.

7

meta

É um dicionário que contém valores para metadados da solicitação.

8

encoding

É uma string contendo a codificação utf-8 usada para codificar o URL.

9

priority

É um número inteiro em que o planejador usa a prioridade para definir o pedido de processamento das solicitações.

10

dont_filter

É um booleano que especifica que o planejador não deve filtrar a solicitação.

11

errback

É uma função chamável a ser chamada quando uma exceção durante o processamento de uma solicitação é levantada.

Passando dados adicionais para funções de retorno de chamada

A função de retorno de chamada de uma solicitação é chamada quando a resposta é baixada como seu primeiro parâmetro.

Por exemplo -

def parse_page1(self, response): 
   return scrapy.Request("http://www.something.com/some_page.html", 
      callback = self.parse_page2)  

def parse_page2(self, response): 
   self.logger.info("%s page visited", response.url)

Você pode usar Request.meta atributo, se você deseja passar argumentos para funções que podem ser chamadas e receber esses argumentos no segundo retorno de chamada, conforme mostrado no exemplo a seguir -

def parse_page1(self, response): 
   item = DemoItem() 
   item['foremost_link'] = response.url 
   request = scrapy.Request("http://www.something.com/some_page.html", 
      callback = self.parse_page2) 
   request.meta['item'] = item 
   return request  

def parse_page2(self, response): 
   item = response.meta['item'] 
   item['other_link'] = response.url 
   return item

Usando errbacks para capturar exceções no processamento de solicitações

O errback é uma função chamável a ser chamada quando uma exceção durante o processamento de uma solicitação é levantada.

O exemplo a seguir demonstra isso -

import scrapy  

from scrapy.spidermiddlewares.httperror import HttpError 
from twisted.internet.error import DNSLookupError 
from twisted.internet.error import TimeoutError, TCPTimedOutError  

class DemoSpider(scrapy.Spider): 
   name = "demo" 
   start_urls = [ 
      "http://www.httpbin.org/",              # HTTP 200 expected 
      "http://www.httpbin.org/status/404",    # Webpage not found  
      "http://www.httpbin.org/status/500",    # Internal server error 
      "http://www.httpbin.org:12345/",        # timeout expected 
      "http://www.httphttpbinbin.org/",       # DNS error expected 
   ]  
   
   def start_requests(self): 
      for u in self.start_urls: 
         yield scrapy.Request(u, callback = self.parse_httpbin, 
         errback = self.errback_httpbin, 
         dont_filter=True)  
   
   def parse_httpbin(self, response): 
      self.logger.info('Recieved response from {}'.format(response.url)) 
      # ...  
   
   def errback_httpbin(self, failure): 
      # logs failures 
      self.logger.error(repr(failure))  
      
      if failure.check(HttpError): 
         response = failure.value.response 
         self.logger.error("HttpError occurred on %s", response.url)  
      
      elif failure.check(DNSLookupError): 
         request = failure.request 
         self.logger.error("DNSLookupError occurred on %s", request.url) 

      elif failure.check(TimeoutError, TCPTimedOutError): 
         request = failure.request 
         self.logger.error("TimeoutError occurred on %s", request.url)

Request.meta Chaves Especiais

As chaves especiais request.meta são uma lista de meta chaves especiais identificadas por Scrapy.

A tabela a seguir mostra algumas das chaves de Request.meta -

Sr. Não Chave e descrição
1

dont_redirect

É uma chave quando definida como verdadeira, não redireciona a solicitação com base no status da resposta.

2

dont_retry

É uma chave quando definida como verdadeira, não repete as solicitações com falha e será ignorada pelo middleware.

3

handle_httpstatus_list

É uma chave que define quais códigos de resposta por solicitação podem ser permitidos.

4

handle_httpstatus_all

É uma chave usada para permitir qualquer código de resposta para uma solicitação, definindo-o como verdadeiro .

5

dont_merge_cookies

É uma chave usada para evitar a fusão com os cookies existentes, definindo-o como verdadeiro .

6

cookiejar

É uma chave usada para manter várias sessões de cookies por spider.

7

dont_cache

É uma chave usada para evitar o cache de solicitações e respostas HTTP em cada política.

8

redirect_urls

É uma chave que contém URLs pelos quais passam as solicitações.

9

bindaddress

É o IP do endereço IP de saída que pode ser usado para realizar a solicitação.

10

dont_obey_robotstxt

É uma chave quando definida como verdadeira, não filtra as solicitações proibidas pelo padrão de exclusão do robots.txt, mesmo se ROBOTSTXT_OBEY estiver habilitado.

11

download_timeout

Ele é usado para definir o tempo limite (em segundos) por spider que o downloader aguardará antes de expirar.

12

download_maxsize

É usado para definir o tamanho máximo (em bytes) por spider, que o downloader baixará.

13

proxy

O proxy pode ser definido para objetos Request para definir o proxy HTTP para o uso de solicitações.

Solicitar subclasses

Você pode implementar sua própria funcionalidade personalizada criando uma subclasse da classe de solicitação. As subclasses de solicitação integradas são as seguintes -

Objetos FormRequest

A classe FormRequest lida com formulários HTML estendendo a solicitação base. Tem a seguinte classe -

class scrapy.http.FormRequest(url[,formdata, callback, method = 'GET', headers, body, 
   cookies, meta, encoding = 'utf-8', priority = 0, dont_filter = False, errback])

A seguir está o parâmetro -

formdata - É um dicionário com dados de formulário HTML atribuídos ao corpo da solicitação.

Note - Os parâmetros restantes são iguais aos da classe de solicitação e são explicados em Request Objects seção.

Os seguintes métodos de classe são suportados por FormRequest objetos, além de métodos de solicitação -

classmethod from_response(response[, formname = None, formnumber = 0, formdata = None, 
   formxpath = None, formcss = None, clickdata = None, dont_click = False, ...])

A tabela a seguir mostra os parâmetros da classe acima -

Sr. Não Parâmetro e Descrição
1

response

É um objeto usado para preencher previamente os campos do formulário usando o formulário HTML de resposta.

2

formname

É uma string onde o formulário com o atributo name será usado, se especificado.

3

formnumber

É um número inteiro de formulários a ser usado quando há vários formulários na resposta.

4

formdata

É um dicionário de campos nos dados do formulário usados ​​para substituir.

5

formxpath

É uma string quando especificada, o formulário que corresponde ao xpath é usado.

6

formcss

É uma string quando especificada, o formulário que corresponde ao seletor css é usado.

7

clickdata

É um dicionário de atributos usado para observar o controle clicado.

8

dont_click

Os dados do formulário serão enviados sem clicar em nenhum elemento, quando definido como verdadeiro.

Exemplos

A seguir estão alguns dos exemplos de uso de solicitação -

Using FormRequest to send data via HTTP POST

O código a seguir demonstra como retornar FormRequest objeto quando você deseja duplicar o POST do formulário HTML em seu spider -

return [FormRequest(url = "http://www.something.com/post/action", 
   formdata = {'firstname': 'John', 'lastname': 'dave'}, 
   callback = self.after_post)]

Using FormRequest.from_response() to simulate a user login

Normalmente, os sites usam elementos por meio dos quais fornece campos de formulário pré-preenchidos.

o FormRequest.form_response() pode ser usado quando você deseja que esses campos sejam preenchidos automaticamente durante a extração.

O exemplo a seguir demonstra isso.

import scrapy  
class DemoSpider(scrapy.Spider): 
   name = 'demo' 
   start_urls = ['http://www.something.com/users/login.php']  
   def parse(self, response): 
      return scrapy.FormRequest.from_response( 
         response, 
         formdata = {'username': 'admin', 'password': 'confidential'}, 
         callback = self.after_login 
      )  
   
   def after_login(self, response): 
      if "authentication failed" in response.body: 
         self.logger.error("Login failed") 
         return  
      # You can continue scraping here

Objetos de Resposta

É um objeto que indica a resposta HTTP que é fornecida aos spiders para processamento. Tem a seguinte classe -

class scrapy.http.Response(url[, status = 200, headers, body, flags])

A tabela a seguir mostra os parâmetros dos objetos Response -

Sr. Não Parâmetro e Descrição
1

url

É uma string que especifica a resposta do URL.

2

status

É um número inteiro que contém a resposta de status HTTP.

3

headers

É um dicionário contendo cabeçalhos de resposta.

4

body

É uma string com corpo de resposta.

5

flags

É uma lista contendo sinalizadores de resposta.

Subclasses de resposta

Você pode implementar sua própria funcionalidade personalizada criando uma subclasse da classe de resposta. As subclasses de resposta integradas são as seguintes -

TextResponse objects

Os objetos TextResponse são usados ​​para dados binários, como imagens, sons etc., que têm a capacidade de codificar a classe Response básica. Tem a seguinte classe -

class scrapy.http.TextResponse(url[, encoding[,status = 200, headers, body, flags]])

A seguir está o parâmetro -

encoding - É uma string com codificação usada para codificar uma resposta.

Note - Os parâmetros restantes são iguais à classe de resposta e são explicados em Response Objects seção.

A tabela a seguir mostra os atributos suportados pelo objeto TextResponse, além dos métodos de resposta -

Sr. Não Atributo e descrição
1

text

É um corpo de resposta, onde response.text pode ser acessado várias vezes.

2

encoding

É uma string contendo codificação para resposta.

3

selector

É um atributo instanciado no primeiro acesso e usa a resposta como destino.

A tabela a seguir mostra os métodos suportados por objetos TextResponse , além dos métodos de resposta -

Sr. Não Método e Descrição
1

xpath (query)

É um atalho para TextResponse.selector.xpath (query).

2

css (query)

É um atalho para TextResponse.selector.css (query).

3

body_as_unicode()

É um corpo de resposta disponível como um método, onde response.text pode ser acessado várias vezes.

Objetos HtmlResponse

É um objeto que oferece suporte à codificação e à autodescoberta observando o atributo metahttpequiv do HTML. Seus parâmetros são os mesmos da classe de resposta e são explicados na seção Objetos de resposta. Tem a seguinte classe -

class scrapy.http.HtmlResponse(url[,status = 200, headers, body, flags])

Objetos XmlResponse

É um objeto que oferece suporte à codificação e autodescoberta observando a linha XML. Seus parâmetros são os mesmos da classe de resposta e são explicados na seção Objetos de resposta. Tem a seguinte classe -

class scrapy.http.XmlResponse(url[, status = 200, headers, body, flags])

Descrição

Como o próprio nome indica, extratores de link são os objetos usados ​​para extrair links de páginas da web usando scrapy.http.Responseobjetos. No Scrapy, existem extratores integrados, comoscrapy.linkextractors importar LinkExtractor. Você pode personalizar seu próprio extrator de link de acordo com suas necessidades, implementando uma interface simples.

Cada extrator de link tem um método público chamado extract_linksque inclui um objeto Response e retorna uma lista de objetos scrapy.link.Link. Você pode instanciar os extratores de link apenas uma vez e chamar o método extract_links várias vezes para extrair links com respostas diferentes. O CrawlSpiderclass usa extratores de link com um conjunto de regras cujo objetivo principal é extrair links.

Referência do extrator de link integrado

Normalmente, os extratores de link são agrupados com o Scrapy e são fornecidos no módulo scrapy.linkextractors. Por padrão, o extrator de link será LinkExtractor, que é igual em funcionalidade com LxmlLinkExtractor -

from scrapy.linkextractors import LinkExtractor

LxmlLinkExtractor

class scrapy.linkextractors.lxmlhtml.LxmlLinkExtractor(allow = (), deny = (), 
   allow_domains = (), deny_domains = (), deny_extensions = None, restrict_xpaths = (), 
   restrict_css = (), tags = ('a', 'area'), attrs = ('href', ), 
   canonicalize = True, unique = True, process_value = None)

O LxmlLinkExtractor é um extrator de links altamente recomendado, porque tem opções de filtragem úteis e é usado com o HTMLParser robusto do lxml.

Sr. Não Parâmetro e Descrição
1

allow (uma expressão regular (ou lista de))

Ele permite uma única expressão ou grupo de expressões que devem corresponder ao url a ser extraído. Se não for mencionado, corresponderá a todos os links.

2

deny (uma expressão regular (ou lista de))

Ele bloqueia ou exclui uma única expressão ou grupo de expressões que deve corresponder ao url que não deve ser extraído. Se não for mencionado ou deixado em branco, não eliminará os links indesejados.

3

allow_domains (str ou lista)

Ele permite uma única string ou lista de strings que deve corresponder aos domínios dos quais os links serão extraídos.

4

deny_domains (str ou lista)

Ele bloqueia ou exclui uma única string ou lista de strings que devem corresponder aos domínios dos quais os links não devem ser extraídos.

5

deny_extensions (Lista)

Ele bloqueia a lista de strings com as extensões ao extrair os links. Se não for definido, então por padrão ele será definido como IGNORED_EXTENSIONS que contém uma lista predefinida no pacote scrapy.linkextractors .

6

restrict_xpaths (str ou lista)

É uma região de lista XPath de onde os links devem ser extraídos da resposta. Se fornecidos, os links serão extraídos apenas do texto, que é selecionado pelo XPath.

7

restrict_css (str ou lista)

Ele se comporta de forma semelhante ao parâmetro strict_xpaths, que extrairá os links das regiões CSS selecionadas dentro da resposta.

8

tags (str ou lista)

Uma única tag ou uma lista de tags que devem ser consideradas ao extrair os links. Por padrão, será ('a', 'área').

9

attrs (Lista)

Um único atributo ou lista de atributos deve ser considerado ao extrair links. Por padrão, será ('href',).

10

canonicalize (boleano)

O url extraído é trazido para o formato padrão usando scrapy.utils.url.canonicalize_url . Por padrão, será True.

11

unique (boleano)

Ele será usado se os links extraídos forem repetidos.

12

process_value (cobrável)

É uma função que recebe um valor de tags e atributos escaneados. O valor recebido pode ser alterado e devolvido ou então nada será devolvido para rejeitar o link. Se não for usado, por padrão será lambda x: x.

Exemplo

O código a seguir é usado para extrair os links -

<a href = "javascript:goToPage('../other/page.html'); return false">Link text</a>

A seguinte função de código pode ser usada em process_value -

def process_value(val): 
   m = re.search("javascript:goToPage\('(.*?)'", val) 
   if m: 
      return m.group(1)

Descrição

O comportamento dos componentes do Scrapy pode ser modificado usando as configurações do Scrapy. As configurações também podem selecionar o projeto Scrapy que está ativo no momento, caso você tenha vários projetos Scrapy.

Designando as configurações

Você deve notificar o Scrapy sobre qual configuração está usando quando você descarta um site. Para isso, a variável de ambienteSCRAPY_SETTINGS_MODULE deve ser usado e seu valor deve estar na sintaxe de caminho do Python.

Preenchendo as configurações

A tabela a seguir mostra alguns dos mecanismos pelos quais você pode preencher as configurações -

Sr. Não Mecanismo e descrição
1

Command line options

Aqui, os argumentos que são passados ​​têm maior precedência, substituindo outras opções. O -s é usado para substituir uma ou mais configurações.

scrapy crawl myspider -s LOG_FILE = scrapy.log
2

Settings per-spider

Os spiders podem ter suas próprias configurações que substituem as do projeto usando o atributo custom_settings.

class DemoSpider(scrapy.Spider): 
   name = 'demo'  
   custom_settings = { 
      'SOME_SETTING': 'some value', 
   }
3

Project settings module

Aqui, você pode preencher suas configurações personalizadas, como adicionar ou modificar as configurações no arquivo settings.py.

4

Default settings per-command

Cada comando da ferramenta Scrapy define suas próprias configurações no atributo default_settings, para substituir as configurações padrão globais.

5

Default global settings

Essas configurações são encontradas no módulo scrapy.settings.default_settings.

Configurações de acesso

Eles estão disponíveis por meio de self.settings e definidos no spider de base depois de inicializado.

O exemplo a seguir demonstra isso.

class DemoSpider(scrapy.Spider): 
   name = 'demo' 
   start_urls = ['http://example.com']  
   def parse(self, response): 
      print("Existing settings: %s" % self.settings.attributes.keys())

Para usar as configurações antes de inicializar o spider, você deve substituir o método from_crawler no método _init_ () do seu spider. Você pode acessar as configurações por meio do atributo scrapy.crawler.Crawler.settings passado para o método from_crawler .

O exemplo a seguir demonstra isso.

class MyExtension(object): 
   def __init__(self, log_is_enabled = False): 
      if log_is_enabled: 
         print("Enabled log") 
         @classmethod 
   def from_crawler(cls, crawler): 
      settings = crawler.settings 
      return cls(settings.getbool('LOG_ENABLED'))

Justificativa para definir nomes

Os nomes das configurações são adicionados como um prefixo ao componente que eles configuram. Por exemplo, para a extensão robots.txt, os nomes das configurações podem ser ROBOTSTXT_ENABLED, ROBOTSTXT_OBEY, ROBOTSTXT_CACHEDIR, etc.

Referência de configurações integradas

A tabela a seguir mostra as configurações integradas do Scrapy -

Sr. Não Configuração e descrição
1

AWS_ACCESS_KEY_ID

É usado para acessar Amazon Web Services.

Valor padrão: Nenhum

2

AWS_SECRET_ACCESS_KEY

É usado para acessar Amazon Web Services.

Valor padrão: Nenhum

3

BOT_NAME

É o nome do bot que pode ser usado para construir o User-Agent.

Valor padrão: 'scrapybot'

4

CONCURRENT_ITEMS

Número máximo de itens existentes no processador de itens usados ​​para processar paralelamente.

Valor padrão: 100

5

CONCURRENT_REQUESTS

Número máximo de solicitações existentes que o downloader Scrapy executa.

Valor padrão: 16

6

CONCURRENT_REQUESTS_PER_DOMAIN

Número máximo de solicitações existentes executadas simultaneamente para qualquer domínio único.

Valor padrão: 8

7

CONCURRENT_REQUESTS_PER_IP

Número máximo de solicitações existentes executadas simultaneamente para qualquer IP único.

Valor padrão: 0

8

DEFAULT_ITEM_CLASS

É uma classe usada para representar itens.

Valor padrão: 'scrapy.item.Item'

9

DEFAULT_REQUEST_HEADERS

É um cabeçalho padrão usado para solicitações HTTP de Scrapy.

Valor padrão -

{  
   'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,
	*/*;q=0.8', 'Accept-Language': 'en',  
}
10

DEPTH_LIMIT

A profundidade máxima para uma aranha rastrear qualquer site.

Valor padrão: 0

11

DEPTH_PRIORITY

É um número inteiro usado para alterar a prioridade da solicitação de acordo com a profundidade.

Valor padrão: 0

12

DEPTH_STATS

Indica se deve coletar estatísticas de profundidade ou não.

Valor padrão: True

13

DEPTH_STATS_VERBOSE

Esta configuração, quando ativada, o número de solicitações é coletado nas estatísticas para cada profundidade detalhada.

Valor padrão: False

14

DNSCACHE_ENABLED

É usado para habilitar o DNS no cache de memória.

Valor padrão: True

15

DNSCACHE_SIZE

Ele define o tamanho do DNS no cache de memória.

Valor padrão: 10000

16

DNS_TIMEOUT

É usado para definir o tempo limite para o DNS processar as consultas.

Valor padrão: 60

17

DOWNLOADER

É um downloader usado para o processo de rastreamento.

Valor padrão: 'scrapy.core.downloader.Downloader'

18

DOWNLOADER_MIDDLEWARES

É um dicionário contendo o middleware downloader e seus pedidos.

Valor padrão: {}

19

DOWNLOADER_MIDDLEWARES_BASE

É um dicionário que contém o middleware do downloader que está habilitado por padrão.

Valor padrão -

{ 'scrapy.downloadermiddlewares.robotstxt.RobotsTxtMiddleware': 100, }
20

DOWNLOADER_STATS

Esta configuração é usada para habilitar as estatísticas do downloader.

Valor padrão: True

21

DOWNLOAD_DELAY

Ele define o tempo total para o downloader antes de baixar as páginas do site.

Valor padrão: 0

22

DOWNLOAD_HANDLERS

É um dicionário com gerenciadores de download.

Valor padrão: {}

23

DOWNLOAD_HANDLERS_BASE

É um dicionário com manipuladores de download habilitados por padrão.

Valor padrão -

{ 'file': 'scrapy.core.downloader.handlers.file.FileDownloadHandler', }
24

DOWNLOAD_TIMEOUT

É o tempo total para que o downloader espere antes de atingir o tempo limite.

Valor padrão: 180

25

DOWNLOAD_MAXSIZE

É o tamanho máximo de resposta para o downloader fazer o download.

Valor padrão: 1073741824 (1024 MB)

26

DOWNLOAD_WARNSIZE

Ele define o tamanho da resposta para o downloader avisar.

Valor padrão: 33554432 (32 MB)

27

DUPEFILTER_CLASS

É uma classe usada para detecção e filtragem de solicitações duplicadas.

Default value: 'scrapy.dupefilters.RFPDupeFilter'

28

DUPEFILTER_DEBUG

This setting logs all duplicate filters when set to true.

Default value: False

29

EDITOR

It is used to edit spiders using the edit command.

Default value: Depends on the environment

30

EXTENSIONS

It is a dictionary having extensions that are enabled in the project.

Default value: {}

31

EXTENSIONS_BASE

It is a dictionary having built-in extensions.

Default value: { 'scrapy.extensions.corestats.CoreStats': 0, }

32

FEED_TEMPDIR

It is a directory used to set the custom folder where crawler temporary files can be stored.

33

ITEM_PIPELINES

It is a dictionary having pipelines.

Default value: {}

34

LOG_ENABLED

It defines if the logging is to be enabled.

Default value: True

35

LOG_ENCODING

It defines the type of encoding to be used for logging.

Default value: 'utf-8'

36

LOG_FILE

It is the name of the file to be used for the output of logging.

Default value: None

37

LOG_FORMAT

It is a string using which the log messages can be formatted.

Default value: '%(asctime)s [%(name)s] %(levelname)s: %(message)s'

38

LOG_DATEFORMAT

It is a string using which date/time can be formatted.

Default value: '%Y-%m-%d %H:%M:%S'

39

LOG_LEVEL

It defines minimum log level.

Default value: 'DEBUG'

40

LOG_STDOUT

This setting if set to true, all your process output will appear in the log.

Default value: False

41

MEMDEBUG_ENABLED

It defines if the memory debugging is to be enabled.

Default Value: False

42

MEMDEBUG_NOTIFY

It defines the memory report that is sent to a particular address when memory debugging is enabled.

Default value: []

43

MEMUSAGE_ENABLED

It defines if the memory usage is to be enabled when a Scrapy process exceeds a memory limit.

Default value: False

44

MEMUSAGE_LIMIT_MB

It defines the maximum limit for the memory (in megabytes) to be allowed.

Default value: 0

45

MEMUSAGE_CHECK_INTERVAL_SECONDS

It is used to check the present memory usage by setting the length of the intervals.

Default value: 60.0

46

MEMUSAGE_NOTIFY_MAIL

It is used to notify with a list of emails when the memory reaches the limit.

Default value: False

47

MEMUSAGE_REPORT

It defines if the memory usage report is to be sent on closing each spider.

Default value: False

48

MEMUSAGE_WARNING_MB

It defines a total memory to be allowed before a warning is sent.

Default value: 0

49

NEWSPIDER_MODULE

It is a module where a new spider is created using genspider command.

Default value: ''

50

RANDOMIZE_DOWNLOAD_DELAY

It defines a random amount of time for a Scrapy to wait while downloading the requests from the site.

Default value: True

51

REACTOR_THREADPOOL_MAXSIZE

It defines a maximum size for the reactor threadpool.

Default value: 10

52

REDIRECT_MAX_TIMES

It defines how many times a request can be redirected.

Default value: 20

53

REDIRECT_PRIORITY_ADJUST

This setting when set, adjusts the redirect priority of a request.

Default value: +2

54

RETRY_PRIORITY_ADJUST

This setting when set, adjusts the retry priority of a request.

Default value: -1

55

ROBOTSTXT_OBEY

Scrapy obeys robots.txt policies when set to true.

Default value: False

56

SCHEDULER

It defines the scheduler to be used for crawl purpose.

Default value: 'scrapy.core.scheduler.Scheduler'

57

SPIDER_CONTRACTS

It is a dictionary in the project having spider contracts to test the spiders.

Default value: {}

58

SPIDER_CONTRACTS_BASE

It is a dictionary holding Scrapy contracts which is enabled in Scrapy by default.

Default value −

{ 
   'scrapy.contracts.default.UrlContract' : 1, 
   'scrapy.contracts.default.ReturnsContract': 2, 
}
59

SPIDER_LOADER_CLASS

It defines a class which implements SpiderLoader API to load spiders.

Default value: 'scrapy.spiderloader.SpiderLoader'

60

SPIDER_MIDDLEWARES

It is a dictionary holding spider middlewares.

Default value: {}

61

SPIDER_MIDDLEWARES_BASE

It is a dictionary holding spider middlewares that is enabled in Scrapy by default.

Default value −

{ 
   'scrapy.spidermiddlewares.httperror.HttpErrorMiddleware': 50, 
}
62

SPIDER_MODULES

It is a list of modules containing spiders which Scrapy will look for.

Default value: []

63

STATS_CLASS

It is a class which implements Stats Collector API to collect stats.

Default value: 'scrapy.statscollectors.MemoryStatsCollector'

64

STATS_DUMP

This setting when set to true, dumps the stats to the log.

Default value: True

65

STATSMAILER_RCPTS

Once the spiders finish scraping, Scrapy uses this setting to send the stats.

Default value: []

66

TELNETCONSOLE_ENABLED

It defines whether to enable the telnetconsole.

Default value: True

67

TELNETCONSOLE_PORT

It defines a port for telnet console.

Default value: [6023, 6073]

68

TEMPLATES_DIR

It is a directory containing templates that can be used while creating new projects.

Default value: templates directory inside scrapy module

69

URLLENGTH_LIMIT

It defines the maximum limit of the length for URL to be allowed for crawled URLs.

Default value: 2083

70

USER_AGENT

It defines the user agent to be used while crawling a site.

Default value: "Scrapy/VERSION (+http://scrapy.org)"

For other Scrapy settings, go to this link.

Description

The irregular events are referred to as exceptions. In Scrapy, exceptions are raised due to reasons such as missing configuration, dropping item from the item pipeline, etc. Following is the list of exceptions mentioned in Scrapy and their application.

DropItem

Item Pipeline utilizes this exception to stop processing of the item at any stage. It can be written as −

exception (scrapy.exceptions.DropItem)

CloseSpider

This exception is used to stop the spider using the callback request. It can be written as −

exception (scrapy.exceptions.CloseSpider)(reason = 'cancelled')

It contains parameter called reason (str) which specifies the reason for closing.

For instance, the following code shows this exception usage −

def parse_page(self, response): 
   if 'Bandwidth exceeded' in response.body: 
      raise CloseSpider('bandwidth_exceeded')

IgnoreRequest

This exception is used by scheduler or downloader middleware to ignore a request. It can be written as −

exception (scrapy.exceptions.IgnoreRequest)

NotConfigured

It indicates a missing configuration situation and should be raised in a component constructor.

exception (scrapy.exceptions.NotConfigured)

Essa exceção pode ser gerada, se algum dos componentes a seguir estiver desabilitado.

  • Extensions
  • Pipelines de item
  • Downloader middlewares
  • Middlewares de aranha

Não suportado

Essa exceção é gerada quando qualquer recurso ou método não é compatível. Pode ser escrito como -

exception (scrapy.exceptions.NotSupported)

Descrição

Para descartar os dados de páginas da web, primeiro você precisa criar o projeto Scrapy onde armazenará o código. Para criar um novo diretório, execute o seguinte comando -

scrapy startproject first_scrapy

O código acima criará um diretório com o nome first_scrapy e conterá a seguinte estrutura -

first_scrapy/
scrapy.cfg            # deploy configuration file
first_scrapy/         # project's Python module, you'll import your code from here
__init__.py
items.py              # project items file
pipelines.py          # project pipelines file
settings.py           # project settings file
spiders/              # a directory where you'll later put your spiders
__init__.py

Descrição

Os itens são os contêineres usados ​​para coletar os dados que são descartados dos sites. Você deve iniciar sua aranha definindo seu item. Para definir itens, editeitems.py arquivo encontrado no diretório first_scrapy(diretório personalizado). O items.py se parece com o seguinte -

import scrapy  

class First_scrapyItem(scrapy.Item): 
   # define the fields for your item here like: 
      # name = scrapy.Field()

A classe MyItem é herdada de Item contendo uma série de objetos predefinidos que Scrapy já construiu para nós. Por exemplo, se você deseja extrair o nome, URL e descrição dos sites, você precisa definir os campos para cada um desses três atributos.

Portanto, vamos adicionar os itens que queremos coletar -

from scrapy.item import Item, Field  

class First_scrapyItem(scrapy.Item): 
   name = scrapy.Field() 
   url = scrapy.Field() 
   desc = scrapy.Field()

Descrição

Spider é uma classe que define o URL inicial de onde extrair os dados, como seguir os links de paginação e como extrair e analisar os campos definidos no items.py. O Scrapy fornece diferentes tipos de aranhas, cada uma com uma finalidade específica.

Crie um arquivo chamado "first_spider.py"sob o diretório first_scrapy / spiders, onde podemos dizer ao Scrapy como encontrar os dados exatos que estamos procurando. Para isso, você deve definir alguns atributos -

  • name - Define o nome exclusivo da aranha.

  • allowed_domains - Ele contém os URLs básicos para o spider rastrear.

  • start-urls - Uma lista de URLs de onde o spider começa a rastrear.

  • parse() - É um método que extrai e analisa os dados copiados.

O código a seguir demonstra a aparência de um código de aranha -

import scrapy  

class firstSpider(scrapy.Spider): 
   name = "first" 
   allowed_domains = ["dmoz.org"] 
   
   start_urls = [ 
      "http://www.dmoz.org/Computers/Programming/Languages/Python/Books/", 
      "http://www.dmoz.org/Computers/Programming/Languages/Python/Resources/" 
   ]  
   def parse(self, response): 
      filename = response.url.split("/")[-2] + '.html' 
      with open(filename, 'wb') as f: 
         f.write(response.body)

Descrição

Para executar seu spider, execute o seguinte comando em seu diretório first_scrapy -

scrapy crawl first

Onde, first é o nome da aranha especificada durante a criação da aranha.

Uma vez que a aranha rasteja, você pode ver a seguinte saída -

2016-08-09 18:13:07-0400 [scrapy] INFO: Scrapy started (bot: tutorial)
2016-08-09 18:13:07-0400 [scrapy] INFO: Optional features available: ...
2016-08-09 18:13:07-0400 [scrapy] INFO: Overridden settings: {}
2016-08-09 18:13:07-0400 [scrapy] INFO: Enabled extensions: ...
2016-08-09 18:13:07-0400 [scrapy] INFO: Enabled downloader middlewares: ...
2016-08-09 18:13:07-0400 [scrapy] INFO: Enabled spider middlewares: ...
2016-08-09 18:13:07-0400 [scrapy] INFO: Enabled item pipelines: ...
2016-08-09 18:13:07-0400 [scrapy] INFO: Spider opened
2016-08-09 18:13:08-0400 [scrapy] DEBUG: Crawled (200) 
<GET http://www.dmoz.org/Computers/Programming/Languages/Python/Resources/> (referer: None)
2016-08-09 18:13:09-0400 [scrapy] DEBUG: Crawled (200) 
<GET http://www.dmoz.org/Computers/Programming/Languages/Python/Books/> (referer: None)
2016-08-09 18:13:09-0400 [scrapy] INFO: Closing spider (finished)

Como você pode ver na saída, para cada URL há uma linha de log que (referenciador: Nenhum) afirma que os URLs são URLs iniciais e não têm referenciadores. Em seguida, você deve ver dois novos arquivos chamados Books.html e Resources.html criados em seu diretório first_scrapy .

Descrição

Para extrair dados de páginas da web, o Scrapy usa uma técnica chamada seletores com base em expressões XPath e CSS . A seguir estão alguns exemplos de expressões XPath -

  • /html/head/title - Isso selecionará o elemento <title>, dentro do elemento <head> de um documento HTML.

  • /html/head/title/text() - Isso selecionará o texto dentro do mesmo elemento <title>.

  • //td - Isso selecionará todos os elementos de <td>.

  • //div[@class = "slice"]- Isso selecionará todos os elementos de div que contêm um atributo class = "slice"

Os seletores têm quatro métodos básicos, conforme mostrado na tabela a seguir -

Sr. Não Método e Descrição
1

extract()

Ele retorna uma string Unicode junto com os dados selecionados.

2

re()

Ele retorna uma lista de strings Unicode, extraídas quando a expressão regular foi fornecida como argumento.

3

xpath()

Ele retorna uma lista de seletores, que representa os nós selecionados pela expressão xpath fornecida como um argumento.

4

css()

Ele retorna uma lista de seletores, que representa os nós selecionados pela expressão CSS fornecida como um argumento.

Usando Seletores no Shell

Para demonstrar os seletores com o shell Scrapy integrado, você precisa ter o IPython instalado em seu sistema. O importante aqui é que os URLs devem ser incluídos entre aspas durante a execução do Scrapy; caso contrário, os URLs com caracteres '&' não funcionarão. Você pode iniciar um shell usando o seguinte comando no diretório de nível superior do projeto -

scrapy shell "http://www.dmoz.org/Computers/Programming/Languages/Python/Books/"

Uma concha terá a seguinte aparência -

[ ... Scrapy log here ... ]

2014-01-23 17:11:42-0400 [scrapy] DEBUG: Crawled (200) 
<GET http://www.dmoz.org/Computers/Programming/Languages/Python/Books/>(referer: None)
[s] Available Scrapy objects:
[s]   crawler    <scrapy.crawler.Crawler object at 0x3636b50>
[s]   item       {}
[s]   request    <GET http://www.dmoz.org/Computers/Programming/Languages/Python/Books/>
[s]   response   <200 http://www.dmoz.org/Computers/Programming/Languages/Python/Books/>
[s]   settings   <scrapy.settings.Settings object at 0x3fadc50>
[s]   spider     <Spider 'default' at 0x3cebf50>
[s] Useful shortcuts:
[s]   shelp()           Shell help (print this help)
[s]   fetch(req_or_url) Fetch request (or URL) and update local objects
[s]   view(response)    View response in a browser

In [1]:

Quando o shell é carregado, você pode acessar o corpo ou cabeçalho usando response.body e response.header respectivamente. Da mesma forma, você pode executar consultas na resposta usando response.selector.xpath () ou response.selector.css () .

Por exemplo -

In [1]: response.xpath('//title')
Out[1]: [<Selector xpath = '//title' data = u'<title>My Book - Scrapy'>]

In [2]: response.xpath('//title').extract()
Out[2]: [u'<title>My Book - Scrapy: Index: Chapters</title>']

In [3]: response.xpath('//title/text()')
Out[3]: [<Selector xpath = '//title/text()' data = u'My Book - Scrapy: Index:'>]

In [4]: response.xpath('//title/text()').extract()
Out[4]: [u'My Book - Scrapy: Index: Chapters']

In [5]: response.xpath('//title/text()').re('(\w+):')
Out[5]: [u'Scrapy', u'Index', u'Chapters']

Extraindo os dados

Para extrair dados de um site HTML normal, temos que inspecionar o código-fonte do site para obter XPaths. Depois de inspecionar, você pode ver que os dados estarão noultag. Selecione os elementos dentroli tag.

As linhas de código a seguir mostram a extração de diferentes tipos de dados -

Para selecionar dados dentro da tag li -

response.xpath('//ul/li')

Para selecionar descrições -

response.xpath('//ul/li/text()').extract()

Para selecionar títulos de sites -

response.xpath('//ul/li/a/text()').extract()

Para selecionar links de sites -

response.xpath('//ul/li/a/@href').extract()

O código a seguir demonstra o uso dos extratores acima -

import scrapy

class MyprojectSpider(scrapy.Spider):
   name = "project"
   allowed_domains = ["dmoz.org"]
   
   start_urls = [
      "http://www.dmoz.org/Computers/Programming/Languages/Python/Books/",
      "http://www.dmoz.org/Computers/Programming/Languages/Python/Resources/"
   ]
   def parse(self, response):
      for sel in response.xpath('//ul/li'):
         title = sel.xpath('a/text()').extract()
         link = sel.xpath('a/@href').extract()
         desc = sel.xpath('text()').extract()
         print title, link, desc

Descrição

Itemobjetos são os dicts regulares de Python. Podemos usar a seguinte sintaxe para acessar os atributos da classe -

>>> item = DmozItem()
>>> item['title'] = 'sample title'
>>> item['title']
'sample title'

Adicione o código acima ao seguinte exemplo -

import scrapy

from tutorial.items import DmozItem

class MyprojectSpider(scrapy.Spider):
   name = "project"
   allowed_domains = ["dmoz.org"]
   
   start_urls = [
      "http://www.dmoz.org/Computers/Programming/Languages/Python/Books/",
      "http://www.dmoz.org/Computers/Programming/Languages/Python/Resources/"
   ]
   def parse(self, response):
      for sel in response.xpath('//ul/li'):
         item = DmozItem()
         item['title'] = sel.xpath('a/text()').extract()
         item['link'] = sel.xpath('a/@href').extract()
         item['desc'] = sel.xpath('text()').extract()
         yield item

A saída do spider acima será -

[scrapy] DEBUG: Scraped from <200 
http://www.dmoz.org/Computers/Programming/Languages/Python/Books/>
   {'desc': [u' - By David Mertz; Addison Wesley. Book in progress, full text, 
      ASCII format. Asks for feedback. [author website, Gnosis Software, Inc.\n],
   'link': [u'http://gnosis.cx/TPiP/'],
   'title': [u'Text Processing in Python']}
[scrapy] DEBUG: Scraped from <200 
http://www.dmoz.org/Computers/Programming/Languages/Python/Books/>
   {'desc': [u' - By Sean McGrath; Prentice Hall PTR, 2000, ISBN 0130211192, 
      has CD-ROM. Methods to build XML applications fast, Python tutorial, DOM and 
      SAX, new Pyxie open source XML processing library. [Prentice Hall PTR]\n'],
   'link': [u'http://www.informit.com/store/product.aspx?isbn=0130211192'],
   'title': [u'XML Processing with Python']}

Descrição

Neste capítulo, estudaremos como extrair os links das páginas de nosso interesse, segui-los e extrair os dados daquela página. Para isso, precisamos fazer as seguintes alterações em nosso código anterior, mostrado a seguir -

import scrapy
from tutorial.items import DmozItem

class MyprojectSpider(scrapy.Spider):
   name = "project"
   allowed_domains = ["dmoz.org"]
   
   start_urls = [
      "http://www.dmoz.org/Computers/Programming/Languages/Python/",
   ]
   def parse(self, response):
      for href in response.css("ul.directory.dir-col > li > a::attr('href')"):
         url = response.urljoin(href.extract())
            yield scrapy.Request(url, callback = self.parse_dir_contents)

   def parse_dir_contents(self, response):
      for sel in response.xpath('//ul/li'):
         item = DmozItem()
         item['title'] = sel.xpath('a/text()').extract()
         item['link'] = sel.xpath('a/@href').extract()
         item['desc'] = sel.xpath('text()').extract()
         yield item

O código acima contém os seguintes métodos -

  • parse() - Extrairá os links de nosso interesse.

  • response.urljoin - O método parse () usará esse método para construir um novo url e fornecer uma nova solicitação, que será enviada posteriormente para retorno de chamada.

  • parse_dir_contents() - Este é um retorno de chamada que realmente apagará os dados de interesse.

Aqui, o Scrapy usa um mecanismo de retorno de chamada para seguir os links. Usando esse mecanismo, o rastreador maior pode ser projetado e pode seguir links de interesse para extrair os dados desejados de páginas diferentes. O método regular será o método de retorno de chamada, que extrairá os itens, procurará links para seguir a próxima página e, em seguida, fornecerá uma solicitação para o mesmo retorno de chamada.

O exemplo a seguir produz um loop, que seguirá os links para a próxima página.

def parse_articles_follow_next_page(self, response):
   for article in response.xpath("//article"):
      item = ArticleItem()
    
      ... extract article data here

      yield item

   next_page = response.css("ul.navigation > li.next-page > a::attr('href')")
   if next_page:
      url = response.urljoin(next_page[0].extract())
      yield scrapy.Request(url, self.parse_articles_follow_next_page)

Descrição

A melhor maneira de armazenar dados extraídos é usando exportações de feed, que garantem que os dados sejam armazenados corretamente usando vários formatos de serialização. JSON, linhas JSON, CSV, XML são os formatos suportados prontamente em formatos de serialização. Os dados podem ser armazenados com o seguinte comando -

scrapy crawl dmoz -o data.json

Este comando irá criar um data.jsonarquivo contendo dados copiados em JSON. Essa técnica é válida para pequenas quantidades de dados. Se uma grande quantidade de dados tiver que ser tratada, podemos usar o Item Pipeline. Assim como o arquivo data.json, um arquivo reservado é configurado quando o projeto é criado emtutorial/pipelines.py.

Descrição

Loggingsignifica rastreamento de eventos, que usa o sistema de registro integrado e define funções e classes para implementar aplicativos e bibliotecas. O registro é um material pronto para uso, que pode funcionar com as configurações de Scrapy listadas nas configurações de registro.

O Scrapy definirá algumas configurações padrão e tratará dessas configurações com a ajuda de scrapy.utils.log.configure_logging () ao executar comandos.

Níveis de registro

Em Python, existem cinco níveis diferentes de gravidade em uma mensagem de log. A lista a seguir mostra as mensagens de log padrão em ordem crescente -

  • logging.DEBUG - para mensagens de depuração (gravidade mais baixa)

  • logging.INFO - para mensagens informativas

  • logging.WARNING - para mensagens de aviso

  • logging.ERROR - para erros regulares

  • logging.CRITICAL - para erros críticos (severidade mais alta)

Como registrar mensagens

O código a seguir mostra o registro de uma mensagem usando logging.info nível.

import logging 
logging.info("This is an information")

A mensagem de registro acima pode ser passada como um argumento usando logging.log mostrado a seguir -

import logging 
logging.log(logging.INFO, "This is an information")

Agora, você também pode usar registradores para incluir a mensagem usando os auxiliares de registro de registro para obter a mensagem de registro claramente mostrada como segue -

import logging
logger = logging.getLogger()
logger.info("This is an information")

Pode haver vários registradores e eles podem ser acessados ​​obtendo seus nomes com o uso de logging.getLogger função mostrada a seguir.

import logging
logger = logging.getLogger('mycustomlogger')
logger.info("This is an information")

Um logger personalizado pode ser usado para qualquer módulo usando a variável __name__ que contém o caminho do módulo mostrado a seguir -

import logging
logger = logging.getLogger(__name__)
logger.info("This is an information")

Log de Spiders

Cada instância do spider tem um logger dentro dele e pode ser usado da seguinte maneira -

import scrapy 

class LogSpider(scrapy.Spider):  
   name = 'logspider' 
   start_urls = ['http://dmoz.com']  
   def parse(self, response): 
      self.logger.info('Parse function called on %s', response.url)

No código acima, o logger é criado usando o nome do Spider, mas você pode usar qualquer logger personalizado fornecido pelo Python, conforme mostrado no código a seguir -

import logging
import scrapy

logger = logging.getLogger('customizedlogger')
class LogSpider(scrapy.Spider):
   name = 'logspider'
   start_urls = ['http://dmoz.com']

   def parse(self, response):
      logger.info('Parse function called on %s', response.url)

Configuração de registro

Os registradores não podem exibir mensagens enviadas por eles próprios. Portanto, eles exigem "manipuladores" para exibir essas mensagens e os manipuladores redirecionarão essas mensagens para seus respectivos destinos, como arquivos, emails e saída padrão.

Dependendo das configurações a seguir, o Scrapy configurará o manipulador do logger.

Configurações de registro

As seguintes configurações são usadas para configurar o registro -

  • o LOG_FILE e LOG_ENABLED decidir o destino das mensagens de log.

  • Quando você define o LOG_ENCODING como falso, ele não exibirá as mensagens de saída do log.

  • o LOG_LEVELirá determinar a ordem de gravidade da mensagem; essas mensagens com menos gravidade serão filtradas.

  • o LOG_FORMAT e LOG_DATEFORMAT são usados ​​para especificar os layouts de todas as mensagens.

  • Quando você define o LOG_STDOUT como verdadeiro, todas as saídas padrão e mensagens de erro do seu processo serão redirecionadas para o log.

Opções de linha de comando

As configurações de scrapy podem ser substituídas passando os argumentos da linha de comando conforme mostrado na tabela a seguir -

Sr. Não Comando e Descrição
1

--logfile FILE

Substitui LOG_FILE

2

--loglevel/-L LEVEL

Substitui LOG_LEVEL

3

--nolog

Define LOG_ENABLED como False

módulo scrapy.utils.log

Esta função pode ser usada para inicializar os padrões de registro para Scrapy.

scrapy.utils.log.configure_logging(settings = None, install_root_handler = True)

Sr. Não Parâmetro e Descrição
1

settings (dict, None)

Ele cria e configura o manipulador para logger root. Por padrão, é Nenhum .

2

install_root_handler (bool)

Ele especifica a instalação do manipulador de registro raiz. Por padrão, é True .

A função acima -

  • Encaminha avisos e registros distorcidos por meio do registro padrão do Python.
  • Atribui DEBUG a Scrapy e o nível de ERROR a registradores Twisted.
  • Rotea stdout para log, se a configuração LOG_STDOUT for verdadeira.

As opções padrão podem ser substituídas usando o settingsargumento. Quando as configurações não são especificadas, os padrões são usados. O manipulador pode ser criado para o logger root, quando install_root_handler é definido como verdadeiro. Se for definido como falso, não haverá nenhuma saída de log definida. Ao usar comandos Scrapy, o configure_logging será chamado automaticamente e pode ser executado explicitamente, enquanto executa os scripts personalizados.

Para configurar a saída de registro manualmente, você pode usar logging.basicConfig() mostrado a seguir -

import logging 
from scrapy.utils.log import configure_logging  

configure_logging(install_root_handler = False) 
logging.basicConfig ( 
   filename = 'logging.txt', 
   format = '%(levelname)s: %(your_message)s', 
   level = logging.INFO 
)

Descrição

O Stats Collector é um recurso fornecido pelo Scrapy para coletar as estatísticas na forma de chaves / valores e é acessado usando a API Crawler (o Crawler fornece acesso a todos os componentes principais do Scrapy). O coletor de estatísticas fornece uma tabela de estatísticas por aranha na qual o coletor de estatísticas abre automaticamente quando a aranha está abrindo e fecha o coletor de estatísticas quando a aranha é fechada.

Usos comuns do coletor de estatísticas

O código a seguir acessa o coletor de estatísticas usando stats atributo.

class ExtensionThatAccessStats(object): 
   def __init__(self, stats): 
      self.stats = stats  
   
   @classmethod 
   def from_crawler(cls, crawler): 
      return cls(crawler.stats)

A tabela a seguir mostra que várias opções podem ser usadas com o coletor de estatísticas -

Sr. Não Parâmetros Descrição
1
stats.set_value('hostname', socket.gethostname())
É usado para definir o valor das estatísticas.
2
stats.inc_value('customized_count')
Ele aumenta o valor da estatística.
3
stats.max_value('max_items_scraped', value)
Você pode definir o valor stat, apenas se for maior que o valor anterior.
4
stats.min_value('min_free_memory_percent', value)
Você pode definir o valor stat, apenas se for inferior ao valor anterior.
5
stats.get_value('customized_count')
Ele busca o valor da estatística.
6
stats.get_stats() {'custom_count': 1, 'start_time': 
datetime.datetime(2009, 7, 14, 21, 47, 28, 977139)}
Ele busca todas as estatísticas

Coletores de estatísticas disponíveis

O Scrapy fornece diferentes tipos de coletores de estatísticas que podem ser acessados ​​usando o STATS_CLASS configuração.

MemoryStatsCollector

É o coletor de estatísticas padrão que mantém as estatísticas de cada aranha que foi usada para raspagem e os dados serão armazenados na memória.

class scrapy.statscollectors.MemoryStatsCollector

DummyStatsCollector

Este coletor de estatísticas é muito eficiente e não faz nada. Isso pode ser definido usando a configuração STATS_CLASS e pode ser usado para desativar a coleta de estatísticas a fim de melhorar o desempenho.

class scrapy.statscollectors.DummyStatsCollector

Descrição

O Scrapy pode enviar e-mails usando seu próprio recurso, chamado de IO sem bloqueio torcido, que evita o IO sem bloqueio do rastreador. Você pode definir algumas configurações de envio de e-mails e fornecer API simples para o envio de anexos.

Existem duas maneiras de instanciar o MailSender, conforme mostrado na tabela a seguir -

Sr. Não Parâmetros Método
1 from scrapy.mail import MailSender mailer = MailSender () Usando um construtor padrão.
2 mailer = MailSender.from_settings (configurações) Usando o objeto Scrapy settings.

A seguinte linha envia um e-mail sem anexos -

mailer.send(to = ["[email protected]"], subject = "subject data", body = "body data", 
   cc = ["[email protected]"])

Referência de classe MailSender

A classe MailSender usa IO sem bloqueio Twisted para enviar e-mails de Scrapy.

class scrapy.mail.MailSender(smtphost = None, mailfrom = None, smtpuser = None, 
   smtppass = None, smtpport = None)

A tabela a seguir mostra os parâmetros usados ​​na classe MailSender -

Sr. Não Parâmetro e Descrição
1

smtphost (str)

O host SMTP é usado para enviar os emails. Caso contrário, a configuração MAIL_HOST será usada.

2

mailfrom (str)

O endereço do destinatário é usado para enviar os e-mails. Caso contrário, a configuração MAIL_FROM será usada.

3

smtpuser

Ele especifica o usuário SMTP. Se não for usada, a configuração MAIL_USER será usada e não haverá validação SMTP se não for mencionada.

4

smtppass (str)

Ele especifica a passagem SMTP para validação.

5

smtpport (int)

Ele especifica a porta SMTP para conexão.

6

smtptls (boolean)

Ele implementa usando o SMTP STARTTLS.

7

smtpssl (boolean)

Ele administra usando uma conexão SSL segura.

Os dois métodos a seguir estão na referência de classe MailSender conforme especificado. Primeiro método,

classmethod from_settings(settings)

Ele incorpora usando o objeto Scrapy settings. Ele contém o seguinte parâmetro -

settings (scrapy.settings.Settings object) - É tratado como receptor de e-mail.

Outro método,

send(to, subject, body, cc = None, attachs = (), mimetype = 'text/plain', charset = None)

A tabela a seguir contém os parâmetros do método acima -

Sr. Não Parâmetro e Descrição
1

to (list)

Refere-se ao destinatário do e-mail.

2

subject (str)

Ele especifica o assunto do e-mail.

3

cc (list)

Refere-se à lista de receptores.

4

body (str)

Refere-se aos dados do corpo do e-mail.

5

attachs (iterable)

Refere-se ao anexo do e-mail, tipo MIME do anexo e nome do anexo.

6

mimetype (str)

Ele representa o tipo MIME do e-mail.

7

charset (str)

Ele especifica a codificação de caracteres usada para o conteúdo do email.

Configurações de correio

As configurações a seguir garantem que, sem escrever nenhum código, possamos configurar um e-mail usando a classe MailSender no projeto.

Sr. Não Configurações e descrição Valor padrão
1

MAIL_FROM

Refere-se ao e-mail do remetente para enviar e-mails.

'scrapy @ localhost'
2

MAIL_HOST

Refere-se ao host SMTP usado para enviar e-mails.

'localhost'
3

MAIL_PORT

Ele especifica a porta SMTP a ser usada para enviar e-mails.

25
4

MAIL_USER

Refere-se à validação SMTP. Não haverá validação, se esta configuração estiver definida como desabilitada.

Nenhum
5

MAIL_PASS

Ele fornece a senha usada para validação SMTP.

Nenhum
6

MAIL_TLS

Ele fornece o método de atualização de uma conexão insegura para uma conexão segura usando SSL / TLS.

Falso
7

MAIL_SSL

Ele implementa a conexão usando uma conexão criptografada SSL.

Falso

Descrição

O console Telnet é um shell Python executado dentro do processo Scrapy e é usado para inspecionar e controlar um processo em execução Scrapy.

Acesse o console Telnet

O console telnet pode ser acessado usando o seguinte comando -

telnet localhost 6023

Basicamente, o console telnet é listado na porta TCP, que é descrito em TELNETCONSOLE_PORT configurações.

Variáveis

Algumas das variáveis ​​padrão fornecidas na tabela a seguir são usadas como atalhos -

Sr. Não Atalho e descrição
1

crawler

Refere-se ao objeto Scrapy Crawler (scrapy.crawler.Crawler).

2

engine

Isso se refere ao atributo Crawler.engine.

3

spider

Isso se refere à aranha que está ativa.

4

slot

Isso se refere ao slot do motor.

5

extensions

Refere-se ao atributo Extension Manager (Crawler.extensions).

6

stats

Refere-se ao atributo Stats Collector (Crawler.stats).

7

setting

Refere-se ao atributo do objeto Scrapy settings (Crawler.settings).

8

est

Isso se refere à impressão de um relatório do status do motor.

9

prefs

Isso se refere à memória para depuração.

10

p

Isso se refere a um atalho para a função pprint.pprint .

11

hpy

Isso se refere à depuração de memória.

Exemplos

A seguir estão alguns exemplos ilustrados usando o console Telnet.

Pause, retome e pare o mecanismo de sucata

Para pausar o mecanismo Scrapy, use o seguinte comando -

telnet localhost 6023
>>> engine.pause()
>>>

Para retomar o mecanismo Scrapy, use o seguinte comando -

telnet localhost 6023
>>> engine.unpause()
>>>

Para parar o mecanismo Scrapy, use o seguinte comando -

telnet localhost 6023
>>> engine.stop()
Connection closed by foreign host.

Exibir status do motor

O console Telnet usa est() método para verificar o status do mecanismo Scrapy, conforme mostrado no código a seguir -

telnet localhost 6023
>>> est()
Execution engine status

time()-engine.start_time                        : 8.62972998619
engine.has_capacity()                           : False
len(engine.downloader.active)                   : 16
engine.scraper.is_idle()                        : False
engine.spider.name                              : followall
engine.spider_is_idle(engine.spider)            : False
engine.slot.closing                             : False
len(engine.slot.inprogress)                     : 16
len(engine.slot.scheduler.dqs or [])            : 0
len(engine.slot.scheduler.mqs)                  : 92
len(engine.scraper.slot.queue)                  : 0
len(engine.scraper.slot.active)                 : 0
engine.scraper.slot.active_size                 : 0
engine.scraper.slot.itemproc_size               : 0
engine.scraper.slot.needs_backout()             : False

Sinais do console Telnet

Você pode usar os sinais do console telnet para adicionar, atualizar ou excluir as variáveis ​​no namespace local telnet. Para executar esta ação, você precisa adicionar o dict telnet_vars em seu manipulador.

scrapy.extensions.telnet.update_telnet_vars(telnet_vars)

Parâmetros -

telnet_vars (dict)

Onde, dict é um dicionário contendo variáveis ​​telnet.

Configurações de Telnet

A tabela a seguir mostra as configurações que controlam o comportamento do console Telnet -

Sr. Não Configurações e descrição Valor padrão
1

TELNETCONSOLE_PORT

Isso se refere ao intervalo de portas para o console telnet. Se for definido como nenhum, a porta será atribuída dinamicamente.

[6023, 6073]
2

TELNETCONSOLE_HOST

Isso se refere à interface na qual o console telnet deve escutar.

'127.0.0.1'

Descrição

Um rastreador da web Scrapy em execução pode ser controlado via JSON-RPC. Ele é ativado pela configuração JSONRPC_ENABLED. Este serviço fornece acesso ao objeto rastreador principal por meio do protocolo JSON-RPC 2.0 . O ponto de extremidade para acessar o objeto rastreador é -

http://localhost:6080/crawler

A tabela a seguir contém algumas das configurações que mostram o comportamento do serviço web -

Sr. Não Configuração e descrição Valor padrão
1

JSONRPC_ENABLED

Refere-se ao booleano, que decide se o serviço web junto com sua extensão será habilitado ou não.

Verdadeiro
2

JSONRPC_LOGFILE

Isso se refere ao arquivo usado para registrar solicitações HTTP feitas ao serviço da web. Se não for definido, o log Scrapy padrão será usado.

Nenhum
3

JSONRPC_PORT

Isso se refere ao intervalo de portas para o serviço da web. Se for definido como nenhum, a porta será atribuída dinamicamente.

[6080, 7030]
4

JSONRPC_HOST

Refere-se à interface em que o serviço da web deve escutar.

'127.0.0.1'