%pip install "google-genai>=1"

from google import genai

# Criar cliente
api_key = "YOUR_API_KEY" # Substituir pela sua chave API.
cliente = genai.Client(api_key=api_key)

# Defina o modelo a ser utilizado
model_id = "gemini-2.0-flash" # Utilize também "gemini-2.0-flash-lite-preview-02-05" ou "gemini-2.0-pro-exp-02-05"

# Carregar ficheiro PDF
invoice_pdf = client.files.upload(file="invoice.pdf", config={'display_name': 'invoice'})

# Ver em quantos tokens o ficheiro é convertido
file_size = client.models.count_tokens(model=model_id, contents=invoice_pdf)
print(f'Ficheiro: {invoice_pdf.display_name} é igual a {file_size.total_tokens} tokens')

# Exemplo de saída: Ficheiro: fatura é igual a 821 tokens

def extract_structured_data(file_path: str, model: BaseModel).
    # Carregamento de um ficheiro para a API File
    file = client.files.upload(file=file_path, config={'display_name': file_path.split('/')[-1].split('.') [0]})

    # Geração de uma resposta estruturada utilizando a API Gemini
    prompt = f "Extrair os dados estruturados do seguinte ficheiro PDF"
    response = client.models.generate_content(model=model_id,
                                             contents=[prompt, file], config={'response_mime_content')
                                             
                                                     'response_schema': model})

    O # transforma a resposta num modelo Pydantic e devolve-a
    return response.parsed

from pydantic import BaseModel, Field

class Item(BaseModel).
    description: str = Field(description="A descrição do item")
    quantidade: float = Field(description="The Qty of the item")
    gross_worth: float = Field(description="O valor bruto do artigo")

class Invoice(BaseModel).
    """Extrair o número da fatura, a data e todos os itens da lista com a descrição, a quantidade e o valor bruto e o valor bruto total. """"
    invoice_number: str = Field(description="O número da fatura, por exemplo, 1234567890")
    date: str = Field(description="A data da fatura, por exemplo, 2024-01-01")
    items: list[Item] = Field(description="A lista de itens com descrição, quantidade e valor bruto")
    total_gross_worth: float = Field(description="O valor bruto total da fatura")

# Extrair os dados utilizando este modelo
result = extract_structured_data("invoice.pdf", Invoice)

# Resultados de saída
print(f "Fatura extraída: {result.invoice_number} em {result.date} com valor bruto total {result.total_gross_worth}")
for item in result.items: print(f "Item: {item_gross_worth}")
    print(f "Item: {item.description} com quantidade {item.quantity} e valor bruto {item.gross_worth}")

classe Form(BaseModel).
    """Extrair o número do formulário, a data de início do exercício, a data de fim do exercício e o passivo do plano no início do ano e no fim do ano. """"
    form_number: str = Field(description="O número do formulário")
    start_date: str = Field(description="Effective Date")
    beginning_of_year: float = Field(description="The plan liabilities beginning of the year")
    end_of_year: float = Field(description="The plan liabilities end of the year")

# Extrair dados
result = extract_structured_data("handwriting_form.pdf", Form)

# Resultados de saída
print(f'Número do formulário extraído: {result.form_number} com data de início {result.start_date}. \nPlano de responsabilidades início do ano {result.beginning_of_year} e fim do ano {result.end_of_year}')
# Exemplo de saída: Número de formulário extraído: CA530082 com data de início 02/05/2022.
# Passivos do plano no início do ano 40000.0 e no final do ano 55000.0

CHUNKING_PROMPT = """OCR a seguinte página em Markdown. As tabelas devem ser formatadas como HTML.
Não coloque três pontos triplos à volta do seu resultado.
Divida o documento em secções de cerca de 250 a 1000 palavras. O nosso objetivo é
O nosso objetivo é identificar partes da página com o mesmo tema semântico.
Estes pedaços serão incorporados e utilizados num pipeline RAG.
Envolva os pedaços com as etiquetas html  .""""

O # usa este prompt para processamento
response = client.models.generate_content(
    model=model_id,
    contents=[CHUNKING_PROMPT, pdf_file]
)

conteúdo_em_cachos = response.text

class Person(BaseModel): first_name: str = Field(description="O primeiro nome da pessoa")
    first_name: str = Field(description="O primeiro nome da pessoa")
    last_name: str = Field(description="O último nome da pessoa")
    last_name: str = Field(description="The last name of the person") last_name: str = Field(description="The last name of the person")
    work_topics: list[Topic] = Field(description="Os domínios de interesse da pessoa; se não forem fornecidos, devolver uma lista vazia")

# Gerar uma resposta utilizando o modelo Pessoa
prompt = "Philipp Schmid é um engenheiro sénior de relações com programadores de IA na Google DeepMind que trabalha no Gemini, Gemma, com a missão de ajudar todos os programadores a construir e beneficiar da IA de uma forma responsável".
response = client.models.generate_content(
    model=model_id,
    contents=prompt,
    config={'response_mime_type': 'application/json', 'response_schema': Person}
)

O SDK # converte automaticamente a resposta para um modelo Pydantic
philipp: Person = response.parsed
print(f "O primeiro nome é {philipp.first_name}")

async def batch_process_pdfs(file_paths, model, batch_size=10):: results = [].
    resultados = []
    for i in range(0, len(file_paths), batch_size):: batch = file_paths[i:i+batch_size): batch = file_paths[i:i
        lote = file_paths[i:i+batch_size]: resultados = [] for i in range(0, len(file_paths), batch_size).
        tarefas = [extract_structured_data(path, model) for path in batch]
        batch_results = await asyncio.gather(*tasks)
        results.extend(batch_results)
        print(f "Lote processado {i//batch_size + 1}/{(len(file_paths)+batch_size-1)//batch_size}")
    retornar resultados

def extract_with_retry(file_path, model, max_retries=3):: for attempt in range(max_retries)
    for attempt in range(max_retries).
        try.
            return extract_structured_data(file_path, model): for attempt in range(max_retries): try.
        except Exception as e: if attempt == max_retries
            if attempt == max_retries - 1: print(f "Falha ao aceder ao ficheiro.
                print(f "Falha ao processar {caminho_do_ficheiro} após {max_retries} tentativas: {e}")
                return None
            print(f "A tentativa {tentativa+1} falhou, nova tentativa: {e}")
            time.sleep(2 ** tentativa) Estratégia de repetição exponencial #

TABLE_EXTRACTION_PROMPT = """Extrair todas as tabelas do PDF como tabelas HTML.
Preserve a estrutura exacta, incluindo células fundidas, cabeçalhos e formatação.
Cada tabela deve ser semanticamente completa e manter as relações entre as células.
Para valores numéricos, mantenha o seu formato exato, tal como apresentado no documento.""""