Eles estão entre nós: os processos repetitivos que ninguém questiona

Quando uma rotina manual parece normal para todo mundo, talvez o estranho seja quem ainda consegue perguntar por que ela continua sendo feita daquele jeito.

Eles estão entre nós.

Não estou falando de aliens.

Estou falando dos processos repetitivos que ficam espalhados pela rotina de trabalho: abrir um software, esperar carregar, consultar uma informação, voltar para uma planilha, preencher um campo, confirmar uma janela e repetir tudo de novo.

Uma vez parece simples.

Várias vezes começa a pesar.

Foi olhando para esse tipo de rotina que desenvolvi uma aplicação em Python para automatizar parte de um processo manual dentro de um software Windows.

A ideia não era criar algo complexo para parecer avançado. Era resolver uma repetição real, daquelas que consomem tempo, atenção e paciência de quem precisa executar.

Antes de automatizar, eu precisei observar

Eu gosto de entender o processo antes de tentar melhorar alguma coisa.

Nesse caso, não bastava saber qual era o resultado esperado. Eu precisava ver como a tarefa acontecia na prática.

Onde a pessoa clicava.
Onde esperava carregar.
Onde conferia a informação.
Onde o sistema demorava.
Onde a automação poderia errar se fosse rápida demais.

Esse detalhe foi importante porque o software tinha telas e abas que levavam alguns milissegundos para carregar. Parece pouco, mas em uma automação isso muda tudo.

Se o robô clica antes da hora, ele pode cair na aba errada.

Se ele continua sem validar a tela, pode preencher uma informação no lugar errado.

Então o primeiro passo foi entender o ritmo do sistema.

A automação precisava ser rápida, mas não podia ser cega.

A base do projeto

Usei Python porque ele me permitiu montar uma aplicação simples, com interface, leitura de arquivos e controle de janelas no Windows.

A stack principal foi esta:

Python
Tkinter
pandas
pywinauto
pywin32
CSV
Excel via COM
PyInstaller

O Tkinter ficou com a interface.

O pandas foi usado para ler e atualizar o CSV.

O pywinauto fez a comunicação com o software Windows: localizar janela, focar no aplicativo, ler elementos da tela, clicar e enviar atalhos.

O pywin32 ajudou na integração com o Excel e em alguns controles do Windows.

No final, usei PyInstaller para transformar o projeto em executável.

O CSV virou a fila do processo

O processo precisava seguir uma lista de itens.

Para isso, usei um CSV como fila de trabalho. Cada linha tinha os dados necessários e um status indicando se aquele item ainda estava pendente ou se já tinha sido processado.

A lógica simplificada era esta:

def proxima_linha_pendente(df):
    for indice, linha in df.iterrows():
        status = str(linha.get("STATUS", "")).strip().lower()

        if status in ["", "pendente", "pending"]:
            return indice, linha

    return None, None

A aplicação buscava a próxima linha pendente, executava o fluxo no software, registrava o resultado e seguia para a próxima.

Também adicionei um controle local de progresso para evitar repetição de itens caso o CSV estivesse aberto, bloqueado ou a execução fosse interrompida.

def marcar_processado(progresso, identificador):
    progresso["sucesso"][identificador] = True
    salvar_json(progresso)

Essa parte deixou a execução mais segura, principalmente durante testes e retomadas.

Controlando o software Windows

A parte central foi fazer o Python controlar um software que não foi criado pensando nessa automação.

Com pywinauto, consegui localizar a janela do aplicativo, focar nela e executar comandos.

from pywinauto import Application, Desktop, keyboard

def conectar_janela():
    desktop = Desktop(backend="uia")

    janela = desktop.window(title_re=".*Aplicativo Externo.*")
    janela.wait("visible", timeout=5)
    janela.set_focus()

    app = Application(backend="uia").connect(handle=janela.handle)

    return app.window(handle=janela.handle)

Depois disso, a aplicação conseguia enviar atalhos e iniciar etapas do fluxo.

def iniciar_novo_item(janela):
    janela.set_focus()
    keyboard.send_keys("^t")

O desafio era garantir que cada ação acontecesse no momento certo.

Em automação de interface, velocidade sem validação vira risco. Por isso, uma das partes mais importantes foi fazer a aplicação ler o que estava visível antes de agir.

Ler a tela antes de clicar

Em vez de seguir apenas uma sequência de cliques, a aplicação passou a validar textos da interface.

def encontrar_texto(janela, texto_alvo):
    for controle in janela.descendants():
        try:
            texto = controle.window_text().strip()

            if texto_alvo in texto:
                return controle
        except Exception:
            continue

    return None

Com isso, o sistema conseguia confirmar se estava na tela certa antes de continuar.

Também usei a leitura dos textos visíveis para identificar informações abertas no aplicativo e comparar com os dados da fila.

def ler_textos_visiveis(janela):
    textos = []

    for controle in janela.descendants():
        try:
            texto = controle.window_text().strip()

            if texto:
                textos.append(texto)
        except Exception:
            continue

    return textos

Esse foi um dos pontos que mais mudou a segurança da automação.

Ela deixou de apenas clicar e passou a conferir o contexto.

Excel em segundo plano

Parte da regra do processo já estava em uma planilha.

Usei o Excel em segundo plano para preencher uma entrada, recalcular e devolver o resultado para o Python.

import win32com.client

def consultar_excel(caminho, valor):
    excel = win32com.client.DispatchEx("Excel.Application")
    excel.Visible = False
    excel.DisplayAlerts = False

    workbook = excel.Workbooks.Open(str(caminho))
    sheet = workbook.Worksheets("Consulta")

    sheet.Range("A2").Value = valor
    excel.CalculateFullRebuild()

    resultado = sheet.Range("B2").Value

    workbook.Close(SaveChanges=False)
    excel.Quit()

    return str(resultado).strip()

Essa integração evitou que alguém precisasse alternar manualmente entre software, planilha e campos de preenchimento.

A planilha continuou fazendo parte do fluxo, só que agora acionada pela automação.

Logs para saber onde parou

Os logs foram essenciais.

Quando algo falhava, eu precisava saber se o problema estava na janela, no texto esperado, no carregamento da aba, na leitura do CSV ou na consulta ao Excel.

Alguns registros simples já ajudavam bastante:

logger.info("Janela localizada.")
logger.info("Texto esperado encontrado.")
logger.info("Linha processada com sucesso.")
logger.error("Texto esperado não encontrado.")

Sem log, a informação seria apenas: “parou”.

Com log, dava para entender onde parou.

Isso acelerou muito os ajustes.

O que ficou desse projeto

Esse projeto nasceu de um incômodo com processos repetitivos que acabam sendo aceitos como parte normal do trabalho.

Eles estão entre nós.

Nas planilhas abertas todos os dias.

Nas telas que exigem sempre os mesmos cliques.

Nos campos preenchidos dezenas de vezes.

Nas conferências repetidas.

Nas tarefas que parecem pequenas, mas ficam pesadas quando se acumulam.

O que eu fiz foi olhar para uma dessas rotinas e transformar a parte mecânica em uma aplicação executável.

Usei Python, controle de janela, leitura de tela, CSV como fila, Excel em segundo plano, logs e empacotamento.

Mas o principal não foi a stack.

O principal foi observar o processo real.

Ver onde ele travava, onde exigia atenção, onde repetia demais e onde poderia ficar mais tranquilo para quem executava.

No fim, a automação não foi só um bot clicando em uma tela.

Foi uma forma de tirar uma parte repetitiva da rotina humana.