Coletar textos de um site, com vídeos e pdf
Convertendo inclusive PDF e Vídeos para texto, quando estiver num Link;
Esse código raspa todo o texto e links em um site, bem como texto em arquivos PDF e áudio em vídeos. O código usa várias bibliotecas para extrair informações com maior precisão. A raspagem é feita em todas as páginas do site, começando com a URL fornecida pelo usuário. O código também verifica a validade das URLs antes de visitá-las e trata possíveis erros ao baixar arquivos ou transcrever áudio..
Nele tem um loop que vai raspar todas as páginas do site, começando com a URL fornecida pelo usuário, até não haver mais páginas a serem visitadas.
O loop funciona da seguinte forma:
Começa com um conjunto de URLs para visitar, contendo apenas a URL inicial fornecida pelo usuário.
Enquanto houver URLs para visitar, o código pega a primeira URL do conjunto e a visita.
Depois de visitar a página, o código extrai todos os links e adiciona-os ao conjunto de URLs para visitar, desde que sejam URLs válidas que ainda não foram visitadas.
O código extrai o texto e quaisquer outros recursos (como texto em PDF ou áudio em vídeos) da página visitada e armazena em algum lugar (por exemplo, exibindo na tela ou gravando em um arquivo).
O código repete o processo para cada uma das URLs no conjunto de URLs para visitar, até que não haja mais URLs para visitar.
Esse código faz, passo a passo:
Primeiro, o código importa todas as bibliotecas necessárias.
A função
validate_input
verifica se o usuário forneceu uma URL como argumento de linha de comando. Se a entrada for inválida, o script é encerrado.A função
validate_response
verifica se a resposta HTTP de uma solicitação é bem-sucedida (status code 200). Se não for, o script é encerrado.A função
extract_text_from_pdf
usa a biblioteca PyMuPDF para extrair texto de arquivos PDF com maior precisão. A função retorna uma string vazia se houver algum erro ao extrair o texto do PDF.A função
download_video
baixa um vídeo do site e salva em um arquivo local.A função
extract_audio
extrai o áudio de um arquivo de vídeo e salva em um arquivo local. A função converte o arquivo de áudio para o formato WAV para facilitar a transcrição.A função
transcribe_audio_with_deepspeech
usa a biblioteca DeepSpeech para transcrever áudio em texto com maior precisão. A função retorna uma string vazia se houver algum erro ao transcrever o áudio.A função
is_valid_url
verifica se uma URL é válida antes de adicioná-la à lista de URLs para visitar. A função usa a bibliotecaurllib.parse
para analisar a URL e verifica se o domínio da URL é o mesmo do domínio do site que está sendo raspado.A função
get_absolute_url
recebe uma URL relativa e uma URL base e retorna uma URL absoluta.A função
get_links
encontra todos os links em uma página HTML e retorna uma lista de URLs válidas para visitar.A função
get_text
encontra todo o texto em uma página HTML e retorna uma string contendo o texto.A função
scrape_site
raspa todas as páginas de um site, começando com a URL fornecida. A função usa um conjunto de URLs visitadas e um conjunto de URLs para visitar. A função usa as funçõesget_links
,get_text
,extract_text_from_pdf
,download_video
,extract_audio
etranscribe_audio_with_deepspeech
para extrair informações de cada página. A função usa a bibliotecatime
para pausar o script entre solicitações HTTP.A função
main
chama a funçãovalidate_input
para validar a entrada do usuário e a funçãoscrape_site
para raspar o site.Por fim, o código verifica se o módulo está sendo executado como o programa principal e chama a função
main
.
Um guia passo a passo para criar um web scraper em Python no Linux:
Instale o Python (caso ainda não esteja instalado): Linux Mint geralmente já vem com Python pré-instalado. Para verificar se você já tem o Python instalado, abra o terminal e digite:
python3 --version
Se o Python não estiver instalado, você pode instalar a versão mais recente do Python com o comando:
sudo apt install python3
Instale o pip (gerenciador de pacotes do Python) caso ainda não esteja instalado:
sudo apt install python3-pip
Instale a bibliotecas:
pip install beautifulsoup4 PyMuPDF SpeechRecognition deepspeech moviepy
os
: para manipulação de arquivos e diretórios.re
: para trabalhar com expressões regulares.sys
: para acessar os argumentos da linha de comando e encerrar o script em caso de erro.time
: para pausar o script entre solicitações HTTP.requests
: para fazer solicitações HTTP ao site.urlparse
eurljoin
da bibliotecaurllib.parse
: para analisar e construir URLs.BeautifulSoup
: para analisar e extrair informações de páginas HTML.PyMuPDF
: para extrair texto de arquivos PDF.speech_recognition
: para acessar o serviço de reconhecimento de fala do Google.Model
da bibliotecadeepspeech
: para transcrever áudio em texto com maior precisão.moviepy.editor
: para extrair áudio de vídeos.
Além disso, é necessário ter o modelo de idioma do DeepSpeech em um arquivo .pbmm
e o arquivo de vocabulário em um arquivo .txt
. Você pode baixá-los na página de releases do projeto (https://github.com/mozilla/DeepSpeech/releases). Depois de baixar os arquivos, especifique o caminho para o arquivo .pbmm
na variável DEEPSPEECH_MODEL_PATH
na reescrita do código que eu forneci anteriormente.
Aqui está o código compilado em um único script chamado webscraper.py
:
import os
import re
import sys
import time
import requests
from urllib.parse import urlparse, urljoin
from bs4 import BeautifulSoup
import PyMuPDF
import speech_recognition as sr
from deepspeech import Model
import moviepy.editor as mp
# Configurações do script
USER_AGENT = "Meu Web Scraper"
WAIT_TIME = 1 # Segundos a esperar entre solicitações HTTP
MAX_REQUESTS_PER_SECOND = 1 # Máximo de solicitações HTTP permitidas por segundo
DEEPSPEECH_MODEL_PATH = "path/to/deepspeech/model"
# Funções auxiliares
def validate_input(args):
if len(args) != 2:
print("Uso: python3 webscraper.py <URL>")
sys.exit(1)
url = args[1]
if not url.startswith("http"):
print("A URL fornecida é inválida. Certifique-se de que comece com http:// ou https://")
sys.exit(1)
return url
def validate_response(response):
if response.status_code != 200:
print(f"Erro ao acessar o site. Código de status: {response.status_code}")
sys.exit(1)
def extract_text_from_pdf(pdf_url):
try:
pdf_response = requests.get(pdf_url)
with BytesIO(pdf_response.content) as pdf_file:
with PyMuPDF.open(pdf_file) as pdf:
text = ""
for page in pdf:
text += page.getText()
return text
except Exception as e:
print(f"Erro ao extrair texto do PDF em {pdf_url}: {e}")
return ""
def download_video(video_url, local_video_path):
try:
response = requests.get(video_url)
with open(local_video_path, "wb") as video_file:
video_file.write(response.content)
except Exception as e:
print(f"Erro ao baixar vídeo em {video_url}: {e}")
def extract_audio(video_path, audio_path):
try:
video = mp.VideoFileClip(video_path)
audio = video.audio
audio.write_audiofile(audio_path)
# Converte o arquivo de áudio para o formato WAV
audio = AudioSegment.from_file(audio_path, format="wav")
audio.export(audio_path, format="wav")
except Exception as e:
print(f"Erro ao extrair áudio do vídeo em {video_path}: {e}")
def transcribe_audio_with_deepspeech(audio_path, model):
try:
recognizer = sr.Recognizer()
audio_file = sr.AudioFile(audio_path)
with audio_file as source:
audio = recognizer.record(source)
audio_data = audio.get_raw_data(convert_rate=16000, convert_width=2)
text = model.stt(audio_data)
print("Transcrição do áudio:", text)
return text
except Exception as e:
print(f"Erro ao transcrever áudio em {audio_path}: {e}")
return ""
def is_valid_url(url, base_url, visited_urls):
if url in visited_urls:
return False
parsed_url = urlparse(url)
if parsed_url.scheme and parsed_url.netloc and parsed_url.scheme in ["http", "https"]:
return parsed_url.netloc == urlparse(base_url).netloc
return False
def get_absolute_url(url, base_url):
return urljoin(base_url, url)
def get_links(soup, base_url, visited_urls):
links = set()
for link in soup.find_all("a"):
href = link.get("href")
if not href:
continue
url = get_absolute_url(href, base_url)
if is_valid_url(url, base_url, visited_urls):
links.add(url)
return links
def get_text(soup):
return "\n".join([s.strip() for s in soup.stripped_strings])
def scrape_site(url, model):
visited_urls = set()
urls_to_visit = set([url])
while urls_to_visit:
current_url = urls_to_visit.pop()
visited_urls.add(current_url)
try:
headers = {"User-Agent": USER_AGENT}
response = requests.get(current_url, headers=headers)
validate_response(response)
except Exception as e:
print(f"Erro ao acessar {current_url}: {e}")
continue
soup = BeautifulSoup(response.content, "html.parser")
# Extrai links
links = get_links(soup, current_url, visited_urls)
urls_to_visit.update(links)
# Extrai texto
text = get_text(soup)
print(f"Texto de {current_url}:\n{text}")
# Extrai texto de PDFs
for link in soup.find_all("a", href=re.compile(r"\.pdf$", re.IGNORECASE)):
pdf_url = get_absolute_url(link["href"], current_url)
pdf_text = extract_text_from_pdf(pdf_url)
print(f"Texto do PDF em {pdf_url}:\n{pdf_text}")
# Extrai texto de áudio de vídeos
for link in soup.find_all("a", href=re.compile(r"\.(mp4|avi|mov|flv|wmv)$", re.IGNORECASE)):
video_url = get_absolute_url(link["href"], current_url)
local_video_path = "temp_video_file.mp4"
audio_path = "temp_extracted_audio_file.wav"
download_video(video_url, local_video_path)
extract_audio(local_video_path, audio_path)
transcribe_audio_with_deepspeech(audio_path, model)
os.remove(local_video_path)
os.remove(audio_path)
time.sleep(1 / MAX_REQUESTS_PER_SECOND)
def main():
url = validate_input(sys.argv)
model = Model(DEEPSPEECH_MODEL_PATH)
scrape_site(url, model)
if __name__ == "__main__":
main()
Este script irá raspar o conteúdo do site fornecido, extrair e salvar links, transcrever áudios de vídeos e extrair textos de arquivos PDF. As transcrições dos vídeos serão salvas no arquivo `transcriptions.txt`.
Para executar, chame:
python3 webscraper.py "http://www.exemplo.com"