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:

1. Primeiro, o código importa todas as bibliotecas necessárias.

2. 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.

3. 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.

4. 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.

5. A função download_video baixa um vídeo do site e salva em um arquivo local.

6. 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.

7. 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.

8. 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 biblioteca urllib.parse para analisar a URL e verifica se o domínio da URL é o mesmo do domínio do site que está sendo raspado.

9. A função get_absolute_url recebe uma URL relativa e uma URL base e retorna uma URL absoluta.

10. A função get_links encontra todos os links em uma página HTML e retorna uma lista de URLs válidas para visitar.

11. A função get_text encontra todo o texto em uma página HTML e retorna uma string contendo o texto.

12. 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ções get_links, get_text, extract_text_from_pdf, download_video, extract_audio e transcribe_audio_with_deepspeech para extrair informações de cada página. A função usa a biblioteca time para pausar o script entre solicitações HTTP.

13. A função main chama a função validate_input para validar a entrada do usuário e a função scrape_site para raspar o site.

14. 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:

1. 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

2. Instale o pip (gerenciador de pacotes do Python) caso ainda não esteja instalado:

sudo apt install python3-pip

3. 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 e urljoin da biblioteca urllib.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 biblioteca deepspeech: 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"