Um Guia para Criar um Leitor de PDF em Python com Google TTS
Tags: python, tts, voice, braziliandevs
Published: 2024-01-15 00:09:39


Nesse guia você vai aprender a criar um leitor de PDF em Python e usar a API do Google Text-to-Speech e gerar um arquivo de áudio narrando o texto escolhido. 
Você pode clonar a o projeto aqui: [Github](https://github.com/StarBR1/pythonBookReader)

Requisitos.
 
requirements.txt
```
gTTS==2.5.0
PyMsgBox==1.0.9
PyMuPDF==1.23.9
```
Você pode instalar as bibliotecas com um  ``` 
pip install -r requirements.txt 
``` 

Vamos começar criando um arquivo pdfToString.py. Esse arquivo vai ser responsável por ler o arquivo PDF selecionado e guardar o valor em uma variável tipo string

Começamos importando as bibliotecas (Não se esqueça de instalar as bibliotecas que citei nos requisitos)

```py
import fitz
import os
```
Vamos definir onde esta o arquivo PDF que será usado.

```py
PDFLocation = os.path.join(os.path.dirname(__file__), 'exemple.pdf')
```
` os.path.dirname(__file__) `   os.path é um sub-modulo do modulo OS e é usado pra entregar o nome do diretório do caminho especificado e evitar problemas de caminho.

O nosso leitor, por não depender de nenhum outro software, de inicio lê o PDF 'cru' e isso pode trazer alguns problemas de ordem dos arquivos. (Exemplo header estar na página 30 por ter sido criado depois)
Pra resolver isso, nós precisamos guardar os valores tanto da página quanto do header

```py
header = "Header"
footer = "Page %i of %i" 
```

Agora precisamos percorrer o arquivo PDF, ler as páginas, extrair o texto delas e guardar em uma variável que vamos usar depois.

```py
for page_number, page in enumerate(doc.pages(), start=1):
    page.insert_text((50, 50), header)
    
    page.insert_text(
        (50, page.rect.height - 50),
        footer % (page_number, doc.page_count),
    )
    extractedPDF += page.get_text()
```
Pra finalizar é interessante fazer uma manipulação de erros, pra caso o OS não encontre o PDF 
```py
if os.path.exists(PDFLocation):
    print(f'{PDFLocation} encontrado')
else:
    print(f'{PDFLocation} não encontrado')
```

Agora vamos criar um arquivo app.py, esse vai se encarregar de receber a string, lê-la e gerar o arquivo localmente. (No final do post eu passo uma opção alternativa para gerar o arquivo no googlecloud)
Vamos importar as bibliotecas e a variavel com a nossa string.

```py
from gtts import gTTS
import os
from pdfToString import extractedPDF
```

Agora vamos definir a função que lê e gera o arquivo

```py
def synthesize_local_audio(output_path):
    text_to_audio = extractedPDF

    tts = gTTS(text=text_to_audio, language_code="pt-BR", name="pt-BR-Neural2-C")
        #Você pode checar as vozes suportadas aqui: https://cloud.google.com/text-to-speech/docs/voices

    tts.save(output_path)

    print(f'Arquivo de áudio salvo em: {output_path}')
```

E tudo pronto :) Rodando o arquivo app.py você verá um arquivo output.wav na pasta onde você selecionou.

### Gerando o arquivo no google cloud
Escrevi um tutorial rapidinho de como preparar o ambiente com as credencias [Preparando ambiente de trabalho-GoogleAPI](https://dev.to/starch1/preparando-o-ambiente-de-trabalho-e-utilizando-apis-google-4j16)
Com tudo isso feito vamos ao codigo
Importe as bibliotecas

```py
from google.cloud import texttospeech, storage
```
[Exemplo do google](https://cloud.google.com/text-to-speech/docs/create-audio-text-long-audio-synthesis?hl=pt-br)
Vamos definir a função que lê a string, gera um arquivo de audio e envia para API do google

```py
def synthesize_long_audio(project_id, location, output_gcs_uri):
    client = texttospeech.TextToSpeechClient()

    textToAudio = extractedPDF

    input = texttospeech.SynthesisInput(text=textToAudio)

    audio_config = texttospeech.AudioConfig(audio_encoding=texttospeech.AudioEncoding.LINEAR16)

    voice = texttospeech.VoiceSelectionParams(language_code="pt-BR", name="pt-BR-Neural2-C") 
        #Supported voices on: https://cloud.google.com/text-to-speech/docs/voices

    request = texttospeech.SynthesizeSpeechRequest(
        input=input,
        voice=voice,
        audio_config=audio_config,
    )
    response = client.synthesize_speech(request=request)

    storage_client = storage.Client()
    bucket_name, object_name = output_gcs_uri.split('/', 2)[-1].split('/', 1)
    bucket = storage_client.get_bucket(bucket_name)
    blob = bucket.blob(object_name)
    blob.upload_from_string(response.audio_content, content_type='audio/wav')

    print(f'\n Created on "{output_gcs_uri}"')
```
Você também precisa passar as credencias do projeto com base nas informações do arquivo json que você baixou da google

```py
project_id = 'SEU_ID'
location = 'SUA_LOCALIZAÇÃO'
output_gcs_uri = 'OUTPUT_DO_BUCKET_QUE_VOCÊ_CRIOU'
```
Tendo tudo pronto, invocamos a função e passamos os argumentos que ela espera. 
```py 
synthesize_long_audio(project_id, location, output_gcs_uri) 
``` 

## Conclusão 

Neste projeto, aprendemos a criar um leitor de PDF em Python utilizando a biblioteca PyMuPDF, a extrair o texto do PDF e a gerar arquivos de áudio localmente com a biblioteca gTTS. Além disso, exploramos a integração com a API Text-to-Speech do Google Cloud para gerar arquivos de áudio e armazená-los no Google Cloud Storage. 

Este guia proporciona uma visão abrangente de como manipular PDFs e realizar síntese de fala, oferecendo aos desenvolvedores uma base sólida para expandir suas habilidades em processamento de texto e áudio com Python.