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 -
|
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 (). |
|
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. |
|
3 | replace_value(field_name, value, *processors, **kwargs) Ele substitui os dados coletados por um novo valor. |
|
4 | get_xpath(xpath, *processors, **kwargs) Ele é usado para extrair cadeias de caracteres Unicode fornecendo processadores e argumentos de palavra-chave ao receber XPath . |
|
5 | add_xpath(field_name, xpath, *processors, **kwargs) Ele recebe XPath para o campo que extrai strings Unicode. |
|
6 | replace_xpath(field_name, xpath, *processors, **kwargs) Ele substitui os dados coletados usando XPath de sites. |
|
7 | get_css(css, *processors, **kwargs) Ele recebe o seletor CSS usado para extrair as strings Unicode. |
|
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. |
|
9 | replace_css(field_name, css, *processors, **kwargs) Ele substitui os dados extraídos usando o seletor CSS. |
|
10 | load_item() Quando os dados são coletados, esse método preenche o item com os dados coletados e os retorna. |
|
11 | nested_xpath(xpath) Ele é usado para criar carregadores aninhados com um seletor XPath. |
|
12 | nested_css(css) É usado para criar carregadores aninhados com um seletor CSS. |
|
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. |
2 | Settings per-spider Os spiders podem ter suas próprias configurações que substituem as do projeto usando o atributo custom_settings. |
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 - |
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 - |
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 - |
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 − |
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 − |
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 | |
É usado para definir o valor das estatísticas. |
2 | |
Ele aumenta o valor da estatística. |
3 | |
Você pode definir o valor stat, apenas se for maior que o valor anterior. |
4 | |
Você pode definir o valor stat, apenas se for inferior ao valor anterior. |
5 | |
Ele busca o valor da estatística. |
6 | |
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' |