📅 CRONOGRAMA REALISTA (15 dias + execução)

FASE 1: Preparação (Dias 1-3)

Meta: Ambiente pronto + primeiros scripts funcionando

FASE 2: Desenvolvimento (Dias 4-12)

Meta: Sistema de extração robusto criado

FASE 3: Testes (Dias 13-15)

Meta: Validado com seus PDFs reais

FASE 4: Execução (Quando começar o trabalho)

Meta: Processar os 500+ casos com segurança

---

🚀 DIA 1: SETUP COMPLETO (3-4 horas)

Manhã: Instalação das Ferramentas

1. Instalar Python 3.11

📥 Download: https://www.python.org/downloads/

IMPORTANTE na instalação:

• ✅ Marcar “Add Python to PATH” (CRÍTICO!)
• ✅ Marcar “Install pip”
• Deixar resto no padrão

Testar se funcionou:

# Abrir terminal/cmd e digitar:
python --version

# Deve mostrar: Python 3.11.x

2. Instalar VS Code

📥 Download: https://code.visualstudio.com/

Depois de instalar:

1. Abrir VS Code
2. Ir em Extensions (ícone de quadradinhos no lado esquerdo)
3. Buscar: “Python”
4. Instalar a extensão da Microsoft (a primeira, tem 100M+ downloads)

3. Instalar Bibliotecas

No terminal/cmd:

pip install pdfplumber pandas openpyxl

Se der erro: tente python -m pip install pdfplumber pandas openpyxl

Tarde: Primeiro Contato com Python

Exercício 1: Hello World (10 min)

# Criar arquivo: ola.py
print("Olá! Vou me tornar um programador!")
print("Meu objetivo: automatizar contracheques")

nome = input("Digite seu nome: ")
print(f"Bem-vindo, {nome}! Vamos começar!")

Executar: Apertar F5 no VS Code OU no terminal: python ola.py

Exercício 2: Calculadora Simples (30 min)

# Arquivo: calculadora.py

print("=== CALCULADORA DE DESCONTOS ===\n")

# Entrada de dados
salario = float(input("Salário bruto: R$ "))
percentual_inss = float(input("% INSS: "))
percentual_ir = float(input("% IR: "))

# Cálculos
desconto_inss = salario * (percentual_inss / 100)
desconto_ir = salario * (percentual_ir / 100)
total_descontos = desconto_inss + desconto_ir
liquido = salario - total_descontos

# Resultados
print("\n=== RESULTADO ===")
print(f"Salário Bruto: R$ {salario:.2f}")
print(f"INSS ({percentual_inss}%): R$ {desconto_inss:.2f}")
print(f"IR ({percentual_ir}%): R$ {desconto_ir:.2f}")
print(f"Total Descontos: R$ {total_descontos:.2f}")
print(f"LÍQUIDO: R$ {liquido:.2f}")

Teste com valores reais do seu contracheque!

Exercício 3: Extrair Texto do Seu PDF (1 hora)

# Arquivo: teste_pdf.py
import pdfplumber

# COLOQUE O NOME EXATO DO SEU PDF AQUI
arquivo_pdf = "02452583-201907-Contracheque do M#s (primeiro desconto no periodo aquisitivo).pdf"

print("Abrindo PDF...\n")

with pdfplumber.open(arquivo_pdf) as pdf:
    # Extrair texto da primeira página
    texto = pdf.pages[0].extract_text()
    
    # Mostrar o texto
    print(texto)
    
    # Salvar em arquivo texto para análise
    with open("texto_extraido.txt", "w", encoding="utf-8") as arquivo:
        arquivo.write(texto)
    
    print("\n✓ Texto salvo em: texto_extraido.txt")

Meta do Dia 1:

• ✅ Python instalado e funcionando
• ✅ VS Code configurado
• ✅ Consegue extrair texto do seu PDF
• ✅ Tem o arquivo texto_extraido.txt para analisar

---

📚 DIA 2: FUNDAMENTOS PYTHON (4-5 horas)

Conceitos Essenciais

1. Variáveis e Tipos (30 min)

# Tipos de dados que você vai usar

# String (texto)
nome = "Willian Aguiar dos Santos"
matricula = "2452583"

# Float (número com vírgula)
salario = 3019.40
liquido = 2914.32

# Integer (número inteiro)
dependentes = 0
dias_trabalhados = 27

# Boolean (verdadeiro/falso)
tem_periculosidade = True
tem_insalubridade = False

# Lista (múltiplos valores)
rubricas = ["Salário Básico", "Adicional Periculosidade", "INSS"]

# Dicionário (dados organizados)
trabalhador = {
    "nome": "Willian",
    "matricula": "2452583",
    "salario": 3019.40
}

# Acessar dados
print(trabalhador["nome"])  # Willian
print(trabalhador["salario"])  # 3019.40

2. Condicionais (1 hora)

# Arquivo: classificador_rubricas.py

def classificar_rubrica(codigo):
    """Classifica se é provento ou desconto"""
    
    # Extrair primeiro dígito
    primeiro_digito = int(codigo[0])
    
    # Lógica de classificação
    if primeiro_digito == 0 and codigo[1] in ['1', '2', '3', '4', '5']:
        return "Provento"
    elif primeiro_digito == 0 and codigo[1] in ['9']:
        return "Desconto"
    elif primeiro_digito == 1:
        return "Provento"
    elif primeiro_digito == 5:
        return "Desconto"
    else:
        return "Indefinido"

# Testar
rubricas_teste = [
    ("0001", "Salário Básico"),
    ("0201", "Adicional Periculosidade"),
    ("0927", "Imposto de Renda"),
    ("1061", "Adicional Noturno"),
    ("5636", "Desc Adiant sal sem IR")
]

print("=== CLASSIFICAÇÃO DE RUBRICAS ===\n")
for codigo, descricao in rubricas_teste:
    tipo = classificar_rubrica(codigo)
    print(f"{codigo} - {descricao}: {tipo}")

3. Loops (1 hora)

# Arquivo: processar_multiplos.py

# Lista de trabalhadores (simulado)
trabalhadores = [
    {"nome": "Willian", "salario": 3019.40, "inss": 642.34},
    {"nome": "Maria", "salario": 3500.00, "inss": 750.00},
    {"nome": "João", "salario": 2800.00, "inss": 580.00},
]

print("=== PROCESSANDO MÚLTIPLOS TRABALHADORES ===\n")

# Loop FOR - percorrer lista
for trabalhador in trabalhadores:
    liquido = trabalhador["salario"] - trabalhador["inss"]
    print(f"{trabalhador['nome']}: R$ {liquido:.2f}")

print("\n=== ESTATÍSTICAS ===")

# Calcular total
total_salarios = 0
for trabalhador in trabalhadores:
    total_salarios += trabalhador["salario"]

media = total_salarios / len(trabalhadores)
print(f"Média salarial: R$ {media:.2f}")

# WHILE - repetir até condição
contador = 0
while contador < len(trabalhadores):
    print(f"Processando trabalhador {contador + 1}...")
    contador += 1

4. Funções (1.5 horas)

# Arquivo: calculador_modular.py

def converter_valor_brasileiro(texto):
    """
    Converte R$ 1.234,56 para float 1234.56
    """
    # Remover "R$" e espaços
    texto = texto.replace("R$", "").strip()
    # Remover pontos de milhar
    texto = texto.replace(".", "")
    # Trocar vírgula por ponto
    texto = texto.replace(",", ".")
    # Converter para float
    return float(texto)

def calcular_inss(salario_base, aliquota=11):
    """Calcula INSS"""
    return salario_base * (aliquota / 100)

def calcular_ir(base_calculo, aliquota=27.5, deducao=869.36):
    """Calcula IR"""
    if base_calculo <= 0:
        return 0
    return (base_calculo * aliquota / 100) - deducao

def processar_folha(dados):
    """
    Processa uma folha completa
    """
    # Proventos
    salario = dados["salario_basico"]
    periculosidade = dados.get("adicional_periculosidade", 0)
    noturno = dados.get("adicional_noturno", 0)
    
    total_proventos = salario + periculosidade + noturno
    
    # Descontos
    inss = calcular_inss(total_proventos)
    base_ir = total_proventos - inss
    ir = calcular_ir(base_ir)
    
    total_descontos = inss + ir
    liquido = total_proventos - total_descontos
    
    return {
        "total_proventos": total_proventos,
        "total_descontos": total_descontos,
        "liquido": liquido,
        "inss": inss,
        "ir": ir
    }

# Teste
trabalhador = {
    "nome": "Willian",
    "salario_basico": 3019.40,
    "adicional_periculosidade": 905.82,
    "adicional_noturno": 785.04
}

resultado = processar_folha(trabalhador)
print(f"Líquido: R$ {resultado['liquido']:.2f}")

# Testar conversor
valor_texto = "R$ 3.019,40"
valor_numero = converter_valor_brasileiro(valor_texto)
print(f"Convertido: {valor_numero}")  # 3019.4

Meta do Dia 2:

• ✅ Entende variáveis, listas, dicionários
• ✅ Usa if/else com confiança
• ✅ Faz loops em listas
• ✅ Cria funções reutilizáveis

---

🔍 DIA 3: EXPRESSÕES REGULARES (3-4 horas)

O que são Regex?

Buscar padrões em texto = “Ctrl+F turbinado”

Conceitos Básicos

import re

texto = "Matrícula: 2452583 | Salário: R$ 3.019,40"

# \d = qualquer dígito (0-9)
# \d{7} = exatamente 7 dígitos
# \d+ = um ou mais dígitos

# Buscar 7 dígitos
matricula = re.search(r'\d{7}', texto)
if matricula:
    print(f"Matrícula: {matricula.group()}")  # 2452583

# Buscar valores em reais
valores = re.findall(r'R\$\s*([\d.,]+)', texto)
print(f"Valores: {valores}")  # ['3.019,40']

Prática com Seu Contracheque

# Arquivo: extrator_regex.py
import re

# Abrir o texto que você salvou no Dia 1
with open("texto_extraido.txt", "r", encoding="utf-8") as f:
    texto = f.read()

print("=== EXTRAINDO DADOS COM REGEX ===\n")

# 1. Matrícula (7 dígitos + palavra "Matrícula")
match = re.search(r'(\d{7})\s+Matrícula', texto)
if match:
    print(f"✓ Matrícula: {match.group(1)}")
else:
    print("✗ Matrícula não encontrada")

# 2. Nome (após "Nome" e antes de "Matrícula")
match = re.search(r'Nome\s+\d+\s+([A-ZÀ-Ú\s]+)\s+Matrícula', texto)
if match:
    print(f"✓ Nome: {match.group(1).strip()}")

# 3. Mês/Ano
match = re.search(r'(\d{2}/\d{4})\s+Mês/Ano', texto)
if match:
    print(f"✓ Mês/Ano: {match.group(1)}")

# 4. Salário Básico
match = re.search(r'0001\s+Salário Básico\s+\d+\s+R\$\s+([\d.,]+)', texto)
if match:
    print(f"✓ Salário Básico: R$ {match.group(1)}")

# 5. Adicional Periculosidade
match = re.search(r'0201\s+Adicional Periculosidade\s+\d+\s+R\$\s+([\d.,]+)', texto)
if match:
    print(f"✓ Periculosidade: R$ {match.group(1)}")

# 6. Total Líquido
match = re.search(r'Total Líquido\s+R\$\s+([\d.,]+)', texto)
if match:
    print(f"✓ Total Líquido: R$ {match.group(1)}")

Criar Tabela de Padrões

# Arquivo: padroes_rubricas.py

# Dicionário com TODOS os padrões do contracheque Petrobras
PADROES = {
    # Informações básicas
    'matricula': r'(\d{7})\s+Matrícula',
    'nome': r'Nome\s+\d+\s+([A-ZÀ-Ú\s]+)\s+Matrícula',
    'mes_ano': r'(\d{2}/\d{4})\s+Mês/Ano',
    
    # Proventos
    'salario_basico': r'0001\s+Salário Básico\s+\d+\s+R\$\s+([\d.,]+)',
    'adicional_periculosidade': r'0201\s+Adicional Periculosidade\s+\d+\s+R\$\s+([\d.,]+)',
    'adicional_noturno': r'1061\s+Adicional Trab\.?\s*Noturno\s+\d+\s+R\$\s+([\d.,]+)',
    'adicional_hra': r'1062\s+Adicional HRA\s+\d+\s+R\$\s+([\d.,]+)',
    'anuenio': r'0015\s+Anuênio\s+[\d,]+\s+R\$\s+([\d.,]+)',
    'ferias': r'1079\s+Férias C/Petros\s+\d+\s+R\$\s+([\d.,]+)',
    'gratificacao_ferias': r'0403\s+Gratificação de Ferias\s+\d+\s+R\$\s+([\d.,]+)',
    'he_troca_turno': r'0528\s+HE Troca de Turno\s+\d+\s+R\$\s+([\d.,]+)',
    
    # Descontos
    'inss': r'0923\s+Contribuição INSS\s+[\d,]+\s+R\$\s+([\d.,]+)',
    'ir': r'0927\s+Imposto de Renda\s+[\d,]+\s+R\$\s+([\d.,]+)',
    'ir_ferias': r'0926\s+Imp Renda Férias\s+[\d,]+\s+R\$\s+([\d.,]+)',
    'petros': r'0985\s+Petros II Contr Regular\s+\d+\s+R\$\s+([\d.,]+)',
    'sindipetro': r'0827\s+Sindipetro Caxias\s+\d+\s+R\$\s+([\d.,]+)',
    
    # Totais
    'total_proventos': r'Total de Proventos\s+\.+\s+R\$\s+([\d.,]+)',
    'total_descontos': r'Total de Descontos\s+\.+\s+R\$\s+([\d.,]+)',
    'total_liquido': r'Total Líquido\s+R\$\s+([\d.,]+)',
}

def extrair_com_padroes(texto):
    """Extrai todos os dados usando os padrões"""
    dados = {}
    
    for campo, padrao in PADROES.items():
        match = re.search(padrao, texto)
        if match:
            dados[campo] = match.group(1)
        else:
            dados[campo] = None
    
    return dados

# Testar
with open("texto_extraido.txt", "r", encoding="utf-8") as f:
    texto = f.read()

dados = extrair_com_padroes(texto)

print("=== TODOS OS DADOS EXTRAÍDOS ===\n")
for campo, valor in dados.items():
    if valor:
        print(f"{campo}: {valor}")

Meta do Dia 3:

• ✅ Entende regex básico
• ✅ Extrai TODOS os campos do seu contracheque
• ✅ Tem dicionário de padrões pronto
• ✅ Taxa de sucesso > 80% na extração

---

 

💾 DIAS 4-5: TRABALHAR COM MÚLTIPLOS PDFS (8 horas total)

Objetivo: Processar todos os seus PDFs de treino

# Arquivo: extrator_completo_v1.py
import pdfplumber
import pandas as pd
import re
from pathlib import Path
from datetime import datetime

# Copiar os PADROES do Dia 3
PADROES = {
    # ... (cole aqui os padrões que você criou)
}

def converter_valor_br(texto):
    """Converte R$ 1.234,56 para float"""
    if not texto:
        return 0.0
    try:
        valor = texto.replace('.', '').replace(',', '.')
        return float(valor)
    except:
        return 0.0

def extrair_contracheque_pdf(caminho_pdf):
    """
    Extrai dados completos de um contracheque
    """
    dados = {
        'arquivo': Path(caminho_pdf).name,
        'status': 'erro',
        'erro_msg': None
    }
    
    try:
        # Abrir PDF
        with pdfplumber.open(caminho_pdf) as pdf:
            if not pdf.pages:
                dados['erro_msg'] = "PDF vazio"
                return dados
            
            # Extrair texto
            texto = pdf.pages[0].extract_text()
            
            if not texto:
                dados['erro_msg'] = "Não foi possível extrair texto"
                return dados
            
            # Extrair cada campo
            for campo, padrao in PADROES.items():
                match = re.search(padrao, texto)
                if match:
                    valor_texto = match.group(1)
                    
                    # Se for valor monetário, converter
                    if any(x in campo for x in ['salario', 'adicional', 'inss', 'ir', 'total', 'liquido', 'ferias', 'petros']):
                        dados[campo] = converter_valor_br(valor_texto)
                    else:
                        dados[campo] = valor_texto
                else:
                    dados[campo] = None
            
            # Validar dados mínimos
            if dados.get('matricula') and dados.get('total_liquido', 0) > 0:
                dados['status'] = 'sucesso'
            else:
                dados['status'] = 'dados_incompletos'
                dados['erro_msg'] = "Matrícula ou líquido não encontrados"
    
    except Exception as e:
        dados['erro_msg'] = str(e)
    
    return dados

def processar_pasta_pdfs(pasta):
    """
    Processa todos os PDFs de uma pasta
    """
    pasta_path = Path(pasta)
    
    # Encontrar todos os PDFs
    pdfs = list(pasta_path.glob("*.pdf"))
    
    if not pdfs:
        print(f"⚠️ Nenhum PDF encontrado em: {pasta}")
        return None
    
    print(f"📄 Encontrados {len(pdfs)} arquivos PDF")
    print(f"🔄 Iniciando processamento...\n")
    print("="*70)
    
    resultados = []
    sucessos = 0
    erros = 0
    
    # Processar cada PDF
    for i, pdf in enumerate(pdfs, 1):
        print(f"[{i:3d}/{len(pdfs)}] {pdf.name[:50]:<50}", end=" ")
        
        dados = extrair_contracheque_pdf(pdf)
        resultados.append(dados)
        
        if dados['status'] == 'sucesso':
            print(f"✓ {dados.get('nome', 'N/A')[:30]}")
            sucessos += 1
        else:
            print(f"✗ {dados.get('erro_msg', 'Erro desconhecido')}")
            erros += 1
    
    print("="*70)
    print(f"\n📊 RESULTADO:")
    print(f"   ✓ Sucessos: {sucessos} ({sucessos/len(pdfs)*100:.1f}%)")
    print(f"   ✗ Erros: {erros} ({erros/len(pdfs)*100:.1f}%)")
    
    # Salvar em Excel
    df = pd.DataFrame(resultados)
    arquivo_saida = f"contracheques_extraidos_{datetime.now().strftime('%Y%m%d_%H%M%S')}.xlsx"
    df.to_excel(arquivo_saida, index=False)
    
    print(f"\n💾 Dados salvos em: {arquivo_saida}")
    
    # Relatório de erros
    if erros > 0:
        print(f"\n⚠️ ARQUIVOS COM ERRO:")
        for r in resultados:
            if r['status'] != 'sucesso':
                print(f"   - {r['arquivo']}: {r['erro_msg']}")
    
    return df

# === EXECUTAR ===
if __name__ == "__main__":
    # SUBSTITUA pela pasta onde estão seus PDFs
    pasta_pdfs = "."  # "." = pasta atual
    
    df = processar_pasta_pdfs(pasta_pdfs)
    
    if df is not None:
        print("\n✓ Processamento concluído!")
        print(f"✓ Abra o arquivo Excel gerado para revisar os dados")

O que fazer nos Dias 4-5:

1. Execute com seus PDFs de treino
2. Anote a taxa de sucesso
3. Para cada erro:
   • Abra o PDF manualmente
   • Veja o que está diferente
   • Ajuste o padrão regex correspondente
4. Repita até taxa de sucesso > 95%

Meta dos Dias 4-5:

• ✅ Processa múltiplos PDFs automaticamente
• ✅ Taxa de sucesso > 95%
• ✅ Gera Excel com todos os dados
• ✅ Identifica padrões de erro

---

 

📊 DIAS 6-8: REFINAMENTO E VALIDAÇÃO (12 horas)

Adicionar Validações Inteligentes

# Arquivo: validador.py

def validar_dados_contracheque(dados):
    """
    Valida se os dados extraídos fazem sentido
    Retorna: (valido, lista_de_avisos)
    """
    avisos = []
    
    # Validação 1: Campos obrigatórios
    if not dados.get('matricula'):
        avisos.append("CRÍTICO: Matrícula não encontrada")
    
    if not dados.get('nome'):
        avisos.append("CRÍTICO: Nome não encontrado")
    
    # Validação 2: Valores numéricos
    liquido = dados.get('total_liquido', 0)
    if liquido <= 0:
        avisos.append("CRÍTICO: Líquido inválido ou zero")
    
    # Validação 3: Coerência matemática
    proventos = dados.get('total_proventos', 0)
    descontos = dados.get('total_descontos', 0)
    liquido_calculado = proventos - descontos
    
    if abs(liquido_calculado - liquido) > 0.02:  # Margem de R$ 0,02
        avisos.append(f"AVISO: Líquido não bate (calc: {liquido_calculado:.2f}, PDF: {liquido:.2f})")
    
    # Validação 4: Descontos não podem ser maiores que proventos
    if descontos > proventos:
        avisos.append("AVISO: Descontos > Proventos (improvável)")
    
    # Validação 5: Valores muito baixos ou altos
    if liquido < 500:
        avisos.append("AVISO: Líquido muito baixo (< R$ 500)")
    
    if liquido > 50000:
        avisos.append("AVISO: Líquido muito alto (> R$ 50.000)")
    
    # Considerar válido se não tiver erros CRÍTICOS
    valido = not any("CRÍTICO" in aviso for aviso in avisos)
    
    return valido, avisos

# Integrar no extrator
def extrair_e_validar(caminho_pdf):
    """Extrai e valida em um único passo"""
    dados = extrair_contracheque_pdf(caminho_pdf)
    
    if dados['status'] == 'sucesso':
        valido, avisos = validar_dados_contracheque(dados)
        dados['validado'] = valido
        dados['avisos'] = '; '.join(avisos) if avisos else None
    
    return dados

Sistema de Logs Detalhado

# Arquivo: logger.py
import logging
from datetime import datetime

def configurar_log():
    """Configura sistema de logs"""
    nome_arquivo = f'extracao_{datetime.now().strftime("%Y%m%d_%H%M%S")}.log'
    
    logging.basicConfig(
        level=logging.DEBUG,
        format='%(asctime)s - %(levelname)s - %(message)s',
        handlers=[
            logging.FileHandler(nome_arquivo, encoding='utf-8'),
            logging.StreamHandler()
        ]
    )
    
    return logging.getLogger(__name__)

# Usar no extrator
logger = configurar_log()

def processar_com_log(pasta_pdfs):
    """Versão com logs detalhados"""
    logger.info("="*60)
    logger.info("INICIANDO PROCESSAMENTO")
    logger.info(f"Pasta: {pasta_pdfs}")
    logger.info("="*60)
    
    pdfs = list(Path(pasta_pdfs).glob("*.pdf"))
    logger.info(f"Encontrados {len(pdfs)} arquivos")
    
    for pdf in pdfs:
        logger.debug(f"Processando: {pdf.name}")
        
        try:
            dados = extrair_e_validar(pdf)
            
            if dados['status'] == 'sucesso':
                logger.info(f"✓ {pdf.name}: {dados['nome']} - R$ {dados['total_liquido']:.2f}")
            else:
                logger.warning(f"✗ {pdf.name}: {dados.get('erro_msg')}")