Professor Carlos - Finanças, Automação e Tecnologia

Relatório Financeiro Automático no E-mail com Apps Script e IA

2026-02-27T08:59:00.000-03:00

Relatório Financeiro Automático no E-mail com Apps Script e IA

Nos posts anteriores, Como usar IA para planejar metas financeiras realistas e Automatizando o Planejamento de Metas com IA e Google Apps Script, você aprendeu a usar IA para definir metas financeiras realistas e a conectar sua planilha à API da OpenAI para gerar análises automáticas. Hoje fechamos o ciclo: vamos fazer o sistema enviar um relatório financeiro completo por e-mail, com as análises da IA, direto para a sua caixa de entrada — todo dia 1º do mês, sem precisar abrir o Google Sheets.

Fonte: https://br.freepik.com/

O que será implementado

Ao final deste tutorial, sua planilha irá apresentar três novas funcionalidades no menu 🤖 Análise IA:

Enviar relatório por e-mail — disparo manual com um clique

Ativar envio automático mensal — configura um trigger (gatilho) para rodar todo dia 1º do mês às 08h

Desativar envio automático — remove o trigger quando quiser pausar

O e-mail gerado inclui um resumo financeiro do mês, as três análises da IA (resumo, alertas e sugestões) e um indicador visual de status (🟢 Saudável, 🟡 Atenção ou 🔴 Crítico) baseado em regras que você mesmo define.

Pré-requisitos

O código dos posts anteriores já instalado no Apps Script da planilha

A chave da OpenAI já salva no PropertiesService

A planilha com pelo menos a aba IA_Analises preenchida (rode 🤖 Análise IA → Analisar minhas metas uma vez antes)

O código Apps Script

Com o editor de script aberto, inclua as seguintes linhas no trecho de configuração que se encontra no início do código:

const EMAIL_DESTINATARIO = Session.getActiveUser().getEmail(); // usa o e-mail do dono da planilha
const LIMITE_ALERTA_COMPROMETIMENTO = 80; // % da renda — acima disso dispara alerta crítico
const LIMITE_ALERTA_META = 50;            // % de cumprimento das metas — abaixo disso dispara alerta

Em seguida, substitua a função onOpen() por esta:

function onOpen() {
  SpreadsheetApp.getUi()
    .createMenu("🤖 Análise IA")
    .addItem("Analisar minhas metas", "analisarMetas")
    .addSeparator()
    .addItem("Enviar relatório por e-mail", "enviarRelatorioEmail")
    .addItem("Ativar envio automático mensal", "ativarTriggerMensal")
    .addItem("Desativar envio automático", "desativarTriggerMensal")
    .addToUi();
}

Ela acrescenta mais três itens no menu 🤖 Análise IA. E, por fim, acrescente estas funções no final do script existente:

//  ENVIO MANUAL DO RELATÓRIO
function enviarRelatorioEmail() {
  const ss      = SpreadsheetApp.getActiveSpreadsheet();
  const analises = lerAbaComoObjeto(ss, "IA_Analises");
  const resumo   = lerAbaComoObjeto(ss, "Resumo_Mensal");
  const config   = lerAbaComoObjeto(ss, "Configurações");

  // Verifica se já existe análise gerada
  if (!analises["Resumo mensal"]) {
    SpreadsheetApp.getUi().alert("Nenhuma análise encontrada. Execute 'Analisar minhas metas' primeiro.");
    return;
  }

  const nivel  = avaliarNivelAlerta(resumo, ss);
  const html   = montarEmailHtml(config, analises, resumo, nivel);
  const assunto = montarAssunto(config, nivel);

  GmailApp.sendEmail(EMAIL_DESTINATARIO, assunto, "", { htmlBody: html });
  SpreadsheetApp.getUi().alert(`✅ Relatório enviado para ${EMAIL_DESTINATARIO}`);
}

//  FUNÇÃO CHAMADA PELO TRIGGER AUTOMÁTICO
function enviarRelatorioAutomatico() {
  const ss = SpreadsheetApp.getActiveSpreadsheet();

  // Roda a análise de IA antes de enviar
  analisarMetas();

  const analises = lerAbaComoObjeto(ss, "IA_Analises");
  const resumo   = lerAbaComoObjeto(ss, "Resumo_Mensal");
  const config   = lerAbaComoObjeto(ss, "Configurações");

  const nivel  = avaliarNivelAlerta(resumo, ss);
  const html   = montarEmailHtml(config, analises, resumo, nivel);
  const assunto = montarAssunto(config, nivel);

  GmailApp.sendEmail(EMAIL_DESTINATARIO, assunto, "", { htmlBody: html });
}

//  AVALIAÇÃO DO NÍVEL DE ALERTA
function avaliarNivelAlerta(resumo, ss) {
  const comprometido = parseFloat(resumo["% da Renda Comprometida"]) || 0;
  const metas        = lerAbaComoTabela(ss, "Metas_Mensais");

  const metasComDesvio = metas.filter(m => {
    const ideal     = parseFloat(m["Valor ideal"]) || 0;
    const realizado = parseFloat(m["Valor realizado"]) || 0;
    return ideal > 0 && (realizado / ideal) * 100 < LIMITE_ALERTA_META;
  });

  if (comprometido >= LIMITE_ALERTA_COMPROMETIMENTO || metasComDesvio.length >= 2) return "CRÍTICO 🔴";
  if (comprometido >= 65 || metasComDesvio.length === 1) return "ATENÇÃO 🟡";
  return "SAUDÁVEL 🟢";
}

//  MONTAGEM DO ASSUNTO DO E-MAIL
function montarAssunto(config, nivel) {
  const periodo = config["Mês/Ano"] || "este mês";
  return `[${nivel}] Relatório de Metas Financeiras — ${periodo}`;
}

//  MONTAGEM DO HTML DO E-MAIL
function montarEmailHtml(config, analises, resumo, nivel) {
  const corNivel = nivel.includes("CRÍTICO") ? "#e74c3c"
                 : nivel.includes("ATENÇÃO")  ? "#f39c12"
                 : "#27ae60";

  return `
  <div style="font-family: Arial, sans-serif; max-width: 620px; margin: auto; color: #333;">

    <div style="background: ${corNivel}; padding: 20px; border-radius: 8px 8px 0 0;">
      <h2 style="color: #fff; margin: 0;">📊 Relatório de Metas Financeiras</h2>
      <p style="color: #fff; margin: 6px 0 0;">${config["Mês/Ano"] || ""} — Status: <strong>${nivel}</strong></p>
    </div>

    <div style="background: #f9f9f9; padding: 20px; border: 1px solid #ddd;">

      <h3 style="color: #555;">📌 Resumo do Mês</h3>
      <table style="width:100%; border-collapse: collapse; font-size: 14px;">
        <tr><td style="padding:6px; border-bottom:1px solid #eee;">Total de Receitas</td>
            <td style="padding:6px; border-bottom:1px solid #eee; font-weight:bold;">R$ ${resumo["Total de Receitas"] || 0}</td></tr>
        <tr><td style="padding:6px; border-bottom:1px solid #eee;">Total de Despesas</td>
            <td style="padding:6px; border-bottom:1px solid #eee; font-weight:bold;">R$ ${resumo["Total de Despesas"] || 0}</td></tr>
        <tr><td style="padding:6px; border-bottom:1px solid #eee;">Saldo do Mês</td>
            <td style="padding:6px; border-bottom:1px solid #eee; font-weight:bold;">R$ ${resumo["Saldo do Mês"] || 0}</td></tr>
        <tr><td style="padding:6px;">% da Renda Comprometida</td>
            <td style="padding:6px; font-weight:bold;">${resumo["% da Renda Comprometida"] || 0}</td></tr>
      </table>

      <h3 style="color: #555; margin-top: 24px;">🤖 Análise da IA</h3>

      <h4 style="margin-bottom: 4px;">Resumo mensal</h4>
      <p style="font-size: 14px; line-height: 1.6;">${analises["Resumo mensal"] || "—"}</p>

      <h4 style="margin-bottom: 4px; color: ${corNivel};">⚠️ Alertas</h4>
      <p style="font-size: 14px; line-height: 1.6;">${analises["Alertas"] || "Nenhum alerta identificado."}</p>

      <h4 style="margin-bottom: 4px; color: #2980b9;">💡 Sugestões</h4>
      <p style="font-size: 14px; line-height: 1.6;">${analises["Sugestões"] || "—"}</p>

    </div>

    <div style="background: #eee; padding: 12px 20px; border-radius: 0 0 8px 8px; font-size: 12px; color: #888;">
      Gerado automaticamente pela sua planilha de Metas Financeiras Inteligentes.
    </div>

  </div>
  `;
}

//  TRIGGER MENSAL — ATIVA (todo dia 1º às 08h)
function ativarTriggerMensal() {
  // Evita duplicação de triggers
  desativarTriggerMensal();

  ScriptApp.newTrigger("enviarRelatorioAutomatico")
    .timeBased()
    .onMonthDay(1)
    .atHour(8)
    .create();

  SpreadsheetApp.getUi().alert("✅ Envio automático ativado! Todo dia 1º às 08h você receberá o relatório.");
}

//  TRIGGER MENSAL — DESATIVA
function desativarTriggerMensal() {
  ScriptApp.getProjectTriggers()
    .filter(t => t.getHandlerFunction() === "enviarRelatorioAutomatico")
    .forEach(t => ScriptApp.deleteTrigger(t));

  // Só mostra alerta se chamado diretamente pelo menu
  const ui = SpreadsheetApp.getUi();
  try { ui.alert("🔕 Envio automático desativado."); } catch(e) {}
}

Como o nível de alerta é calculado

Antes de montar o e-mail, o código avalia dois critérios automaticamente:

Se o % da renda comprometida ultrapassa 80%, o status vai para 🔴 Crítico

Se duas ou mais metas mensais estão abaixo de 50% de cumprimento, também vai para 🔴 Crítico

Valores intermediários resultam em 🟡 Atenção

Tudo dentro do esperado resulta em 🟢 Saudável

Você pode ajustar esses valores limites nas constantes LIMITE_ALERTA_COMPROMETIMENTO e LIMITE_ALERTA_META no topo do código.

O e-mail em HTML

O método GmailApp.sendEmail() do Apps Script aceita o parâmetro htmlBody, o que permite enviar e-mails formatados com tabelas, cores e tipografia — sem depender de nenhum serviço externo. A cor do cabeçalho muda dinamicamente conforme o nível de alerta: vermelho para crítico, amarelo para atenção e verde para saudável.

Ativando o envio automático

Depois de colar o código e salvar, volte para a planilha. No menu 🤖 Análise IA, clique em Ativar envio automático mensal. O Apps Script vai registrar um trigger baseado em tempo que executa a função enviarRelatorioAutomatico todo dia 1º do mês às 08h.

Os parâmetros dia e hora do envio do e-mail podem ser definidos na área de configuração do script.

Importante: na primeira execução, o Google vai pedir autorização para que o script acesse seu Gmail. Isso é esperado — é o fluxo padrão de OAuth do Apps Script para escopos sensíveis.

Você pode verificar os triggers que estão ativos, a qualquer momento em Apps Script → Acionadores (ícone de relógio na barra lateral).

Resultado esperado

No dia 1º de cada mês você recebe um e-mail com:

O status do mês em destaque no assunto, por exemplo: [SAUDÁVEL 🟢] Relatório de Metas Financeiras — Fevereiro/2026

Tabela com os números do mês (receitas, despesas, saldo, % comprometido)

Os três blocos de análise da IA em linguagem natural
Rodapé identificando que foi gerado automaticamente pela planilha

Próximos passos possíveis

Com esse sistema rodando, a evolução natural é trabalhar com histórico e tendências: salvar cada análise mensal na aba Historico e, depois de alguns meses, pedir à IA que identifique padrões de comportamento financeiro ao longo do tempo — o que será tema de outro post no futuro.

Ficou com alguma dúvida na configuração do trigger ou na autorização do Gmail? Deixa nos comentários!

Automatizando o Planejamento de Metas com IA e Google Apps Script

2026-02-22T08:54:00.004-03:00

Automatizando o Planejamento de Metas com IA e Google Apps Script

No post anterior, você aprendeu como a IA pode ajudar a definir metas financeiras realistas e recebeu uma planilha no Google Sheets para colocar esse planejamento em prática. Hoje vamos um passo além: vamos fazer a própria planilha chamar a IA automaticamente e escrever a análise para você — tudo com um clique, usando Google Apps Script e a API da OpenAI.

Fonte: https://br.freepik.com/

O que vamos construir

Ao final deste tutorial, sua planilha terá um menu customizado 🤖 Análise IA que, ao ser acionado, vai:

Ler seus dados financeiros do mês (receitas, despesas, objetivos e metas)
Montar um prompt contextualizado com essas informações
Enviar esse prompt para o modelo gpt-4o (ou outro modelo de sua preferência) via API
Escrever os resultados diretamente na aba IA_Analises da planilha, nas linhas de Resumo mensal, Alertas e Sugestões

Pré-requisitos

A planilha do post anterior (se ainda não tem, baixe aqui)
Uma conta na OpenAI Platform com créditos disponíveis
Conhecimento básico de JavaScript — o Apps Script usa uma variante dele

Obtendo sua chave da API

Acesse platform.openai.com/api-keys, crie uma nova chave e guarde-a em um lugar seguro. Você vai usá-la em instantes.

Neste post mostramos em detalhes como obter sua chave da API OpenAI.

Atenção: nunca exponha sua API key em código compartilhado ou versionado. Mais abaixo mostramos como armazená-la de forma segura usando o PropertiesService do próprio Apps Script.

Acessando o Apps Script

Na sua planilha, vá em Extensões → Apps Script. O editor será aberto em uma nova aba. Apague qualquer código padrão que estiver lá e cole o código abaixo.

O Código Completo

//  CONFIG — use PropertiesService em produção (veja abaixo)

const OPENAI_API_KEY = PropertiesService.getScriptProperties().getProperty("OPENAI_API_KEY");
const OPENAI_MODEL   = "gpt-4o";

//  MENU CUSTOMIZADO

function onOpen() {
  SpreadsheetApp.getUi()
    .createMenu("🤖 Análise IA")
    .addItem("Analisar minhas metas", "analisarMetas")
    .addToUi();
}

//  FUNÇÃO PRINCIPAL

function analisarMetas() {
  const ss = SpreadsheetApp.getActiveSpreadsheet();

  const config    = lerAbaComoObjeto(ss, "Configurações");
  const resumo    = lerAbaComoObjeto(ss, "Resumo_Mensal");
  const objetivos = lerAbaComoTabela(ss, "Objetivos");
  const metas     = lerAbaComoTabela(ss, "Metas_Mensais");

  const prompt  = montarPrompt(config, resumo, objetivos, metas);
  const resposta = chamarOpenAI(prompt);

  if (!resposta) {
    SpreadsheetApp.getUi().alert("Erro ao chamar a API da OpenAI. Verifique os logs.");
    return;
  }

  escreverAnalises(ss, resposta);
  SpreadsheetApp.getUi().alert("✅ Análise concluída! Veja a aba IA_Analises.");
}

//  HELPERS DE LEITURA

function lerAbaComoObjeto(ss, nomeAba) {
  const aba  = ss.getSheetByName(nomeAba);
  if (!aba) return {};
  const dados = aba.getDataRange().getValues();
  const obj   = {};
  dados.forEach(([campo, valor]) => { if (campo) obj[campo] = valor; });
  return obj;
}

function lerAbaComoTabela(ss, nomeAba) {
  const aba = ss.getSheetByName(nomeAba);
  if (!aba) return [];
  const dados     = aba.getDataRange().getValues();
  const cabecalho = dados[0];
  return dados.slice(1)
    .filter(linha => linha.some(cel => cel !== "" && cel !== 0))
    .map(linha => {
      const obj = {};
      cabecalho.forEach((col, i) => { obj[col] = linha[i]; });
      return obj;
    });
}

//  MONTAGEM DO PROMPT

function montarPrompt(config, resumo, objetivos, metas) {
  const objetivosTexto = objetivos.length
    ? objetivos.map(o =>
        `- ${o["Objetivo"]} | Tipo: ${o["Tipo"]} | Prioridade: ${o["Prioridade"]} | ` +
        `Valor: R$ ${o["Valor total"]} | Prazo: ${o["Prazo (meses)"]} meses | Status: ${o["Status"]}`
      ).join("\n")
    : "Nenhum objetivo cadastrado.";

  const metasTexto = metas.length
    ? metas.map(m =>
        `- ${m["Objetivo"]}: Ideal R$ ${m["Valor ideal"]} | Mínimo R$ ${m["Valor mínimo"]} | ` +
        `Sugerido R$ ${m["Valor sugerido"]} | Realizado R$ ${m["Valor realizado"]} | ` +
        `Diferença R$ ${m["Diferença"]}`
      ).join("\n")
    : "Nenhuma meta mensal cadastrada.";

  return `
Você é um consultor financeiro pessoal especializado em planejamento de metas.
Analise os dados financeiros abaixo e responda EXCLUSIVAMENTE no seguinte formato JSON:

{
  "resumo_mensal": "texto corrido com análise geral do mês",
  "alertas": "texto corrido com alertas sobre riscos ou desvios identificados",
  "sugestoes": "texto corrido com sugestões práticas e priorizadas"
}

=== DADOS DO USUÁRIO ===

Perfil: ${config["Perfil financeiro"] || "Não informado"}
Período: ${config["Mês/Ano"] || "Não informado"}
Renda total: R$ ${config["Renda total"] || 0}
Limite de comprometimento: ${config["Limite comprometimento (%)"] || 0}%
Meta mínima de poupança: ${config["Meta mínima (%)"] || 0}%

Resumo do mês:
- Total de Receitas: R$ ${resumo["Total de Receitas"] || 0}
- Total de Despesas: R$ ${resumo["Total de Despesas"] || 0}
- Saldo do Mês: R$ ${resumo["Saldo do Mês"] || 0}
- % da Renda Comprometida: ${resumo["% da Renda Comprometida"] || 0}
- Capacidade para Metas: R$ ${resumo["Capacidade para Metas"] || 0}

Objetivos cadastrados:
${objetivosTexto}

Metas mensais:
${metasTexto}

Responda apenas o JSON, sem markdown, sem explicações fora do JSON.
  `.trim();
}

//  CHAMADA À API DA OPENAI

function chamarOpenAI(prompt) {
  const url     = "https://api.openai.com/v1/chat/completions";
  const payload = {
    model: OPENAI_MODEL,
    messages: [{ role: "user", content: prompt }],
    temperature: 0.7,
    response_format: { type: "json_object" }
  };

  const options = {
    method: "post",
    contentType: "application/json",
    headers: { Authorization: `Bearer ${OPENAI_API_KEY}` },
    payload: JSON.stringify(payload),
    muteHttpExceptions: true
  };

  try {
    const response = UrlFetchApp.fetch(url, options);
    const json     = JSON.parse(response.getContentText());
    if (json.error) {
      console.error("Erro OpenAI:", json.error.message);
      return null;
    }
    return JSON.parse(json.choices[0].message.content);
  } catch (e) {
    console.error("Exceção:", e.message);
    return null;
  }
}

//  ESCRITA NA ABA IA_Analises

function escreverAnalises(ss, resposta) {
  const aba   = ss.getSheetByName("IA_Analises");
  if (!aba) return;
  const dados = aba.getDataRange().getValues();
  dados.forEach((linha, i) => {
    const tipo = linha[0];
    if (tipo === "Resumo mensal")   aba.getRange(i + 1, 2).setValue(resposta.resumo_mensal || "");
    if (tipo === "Alertas")         aba.getRange(i + 1, 2).setValue(resposta.alertas       || "");
    if (tipo === "Sugestões")       aba.getRange(i + 1, 2).setValue(resposta.sugestoes     || "");
  });
}

Armazenando a chave com segurança

Em vez de colocar a API key da OpenAI diretamente no código, use o PropertiesService. Execute a função abaixo uma única vez pelo editor do Apps Script e depois a apague:

function salvarChave() {
  PropertiesService.getScriptProperties().setProperty("OPENAI_API_KEY", "sk-SUA_CHAVE_AQUI");
}

Se preferir pode usar o menu do projeto para armazenar a chave, assim como fizemos no post Como Integrar ChatGPT com Google Sheets usando Google Apps Script.

A partir daí, o código já busca a chave automaticamente com o código PropertiesService.getScriptProperties().getProperty("OPENAI_API_KEY") — sem risco de exposição acidental.

Entendendo o fluxo

Vale a pena detalhar o que acontece por baixo dos panos quando o leitor clica no menu 🤖 Análise IA:

Leitura dos dados — as funções lerAbaComoObjeto e lerAbaComoTabela transformam os dados das abas em objetos JavaScript simples, filtrando linhas vazias automaticamente.
Montagem do prompt — a função montarPrompt injeta esses dados em um prompt estruturado que instrui o modelo a responder apenas em JSON, evitando texto livre que quebraria o parse, o processo de converter os dados recebidos.
Chamada à API — UrlFetchApp.fetch é o equivalente do fetch nativo no ambiente do Apps Script. O parâmetro response_format: { type: "json_object" } garante que o gpt-4o sempre retorne um JSON válido.
Escrita dos resultados — a função escreverAnalises percorre a aba IA_Analises procurando as linhas pelo valor da coluna A ("Resumo mensal", "Alertas", "Sugestões") e escreve o conteúdo correspondente na coluna B.

Resultado esperado

Após clicar em 🤖 Análise IA → Analisar minhas metas, a aba IA_Analises da planilha será preenchida automaticamente com três análises textuais geradas pelo gpt-4o com base nos seus dados reais do mês.

Próximos passos possíveis

Se quiser evoluir esse projeto, algumas ideias:

Histórico de análises — salvar cada análise na aba Historico com data e timestamp

Trigger automático — configurar um gatilho para a análise rodar todo dia 1º do mês sem intervenção manual

Análise do Simulador — incluir os dados da aba Simulador no prompt para que a IA avalie cenários de variação de renda e despesas

Ficou com dúvida ou quer sugerir uma melhoria? Deixa nos comentários!

Como usar IA para planejar metas financeiras realistas

2026-02-08T19:15:00.005-03:00

Como usar IA para planejar metas financeiras realistas

Planejar metas financeiras é algo que quase todo mundo tenta fazer — e quase todo mundo abandona no meio do caminho.
Não por falta de vontade, mas por um motivo simples: as metas não são realistas, nem adaptadas à vida real.

Planilhas genéricas ignoram variáveis importantes, tais como: renda variável, imprevistos, comportamento humano e mudanças ao longo do tempo.
É aqui que a Inteligência Artificial deixa de ser modismo e passa a ser ferramenta prática.

Fonte: https://br.freepik.com/

Neste artigo, você vai aprender:

por que a maioria das metas financeiras falha,
como a IA pode ajudar a criar metas realistas,
e como usar uma planilha inteligente de metas, pensada para se adaptar a você — e não o contrário.

Por que metas financeiras falham tão frequentemente

Antes de falar de IA, precisamos ser honestos.

A maioria das metas financeiras falha porque:

são copiadas de alguém que vive outra realidade,
ignoram gastos variáveis e imprevistos,
dependem exclusivamente de disciplina,
não são revisadas com dados reais.

Exemplos comuns de metas financeiras:

“Vou guardar 30% do salário” (sem saber se sobra isso)
“Vou quitar todas as dívidas em 6 meses” (sem considerar juros e fluxo de caixa)
“Vou investir todo mês” (sem reserva de emergência)

Metas assim não são ambiciosas — são mal calculadas.

Onde a IA entra nesse processo

A IA não serve para “adivinhar o futuro”, mas para analisar padrões, simular cenários e apoiar decisões melhores.

Quando aplicada às finanças pessoais, ela pode:

analisar seu histórico de gastos,
identificar padrões de comportamento financeiro,
sugerir valores de metas baseados na sua realidade,
ajustar metas automaticamente quando algo muda.

Ou seja, em vez de você se adaptar à planilha, a planilha se adapta a você. A seguir eu mostro os passos para o planejamento de uma planilha.

Passo 1: Organize seus dados financeiros

Nenhuma IA funciona sem dados.

Antes de qualquer meta, você precisa responder:

Quanto você ganha por mês (fixo e variável)?
Quanto você gasta, de verdade?
Quais gastos são fixos e quais variam?
Quanto sobra (ou falta) no final do mês?

Uma planilha bem estruturada deve conter:

receitas,
despesas categorizadas,
saldo mensal,
histórico de pelo menos 3 meses.

💡 Importante: não busque perfeição. Busque consistência.

Passo 2: Defina objetivos claros (não valores aleatórios)

Uma meta financeira não começa com “quanto”, mas com “para quê”.

Exemplos de objetivos:

criar uma reserva de emergência,
quitar dívidas específicas,
investir para médio ou longo prazo,
realizar um projeto pessoal.

A IA trabalha melhor quando o objetivo é claro, porque ela consegue:

calcular prazos realistas,
sugerir aportes progressivos,
priorizar metas simultâneas.

Passo 3: Use IA para transformar objetivos em metas possíveis

Aqui está o ponto-chave.

Em vez de definir metas “no chute”, você pode usar IA (como o ChatGPT integrado à planilha ou via prompt manual) para responder perguntas como:

Quanto posso guardar sem comprometer meu padrão de vida?
Qual prazo é mais realista considerando meus gastos?
O que acontece se minha renda cair ou subir?
Vale mais a pena quitar dívidas ou investir agora?

A IA não decide por você — ela mostra cenários. E isso muda tudo.

Passo 4: Planeje metas flexíveis (e não engessadas)

Metas rígidas quebram na primeira dificuldade.

Metas inteligentes:

têm valores mínimos e ideais,
se ajustam automaticamente ao saldo do mês,
permitem pausas sem “culpa financeira”.

Uma boa planilha com apoio de IA deve:

recalcular metas se a renda mudar,
sugerir ajustes quando o saldo ficar negativo,
mostrar impacto de decisões antes de você tomá-las.

Isso reduz abandono e aumenta consistência.

Passo 5: Acompanhe e revise com base em dados

Planejar sem acompanhar é ilusão.

A cada mês, você deve responder:

A meta ainda faz sentido?
O valor planejado foi possível?
O comportamento financeiro mudou?

Com IA, esse processo pode ser automatizado:

resumo mensal automático,
alertas de desvio,
sugestões de ajuste de metas.

Assim, você sai do modo “culpa” e entra no modo gestão.

A planilha de metas financeiras inteligentes

Para colocar tudo isso em prática, eu criei uma planilha de metas financeiras pensada para trabalhar com IA, não contra você.

Ela permite:

definir objetivos claros,
simular cenários,
ajustar metas automaticamente,
acompanhar evolução mensal,
integrar com IA para análises e sugestões.

📊 Clique no link abaixo para fazer uma cópia da planilha no seu Google Drive.
A planilha é somente leitura. Ao clicar, você poderá salvá-la e adaptá-la à sua realidade financeira.

👉 Baixar a planilha de metas financeiras inteligentes

Nos próximos artigos, vou mostrar:

como integrar essa planilha com IA passo a passo,
como automatizar relatórios,
e como criar alertas inteligentes de metas.

Conclusão

Planejar metas financeiras não precisa ser doloroso, rígido ou frustrante.
Com dados, automação e IA, você transforma metas em processos — e processos em resultados.

A tecnologia não substitui decisões.
Mas ajuda você a tomar decisões melhores, com menos estresse e mais clareza.

Se você quer que o dinheiro trabalhe a seu favor, comece pelo planejamento certo.

Macros no LibreOffice: uma base conceitual

2026-01-17T19:19:00.004-03:00

Macros no LibreOffice: uma base conceitual

Macros no LibreOffice são pequenos programas que permitem automatizar tarefas, estender funcionalidades e integrar a suíte com recursos externos. Elas podem ser usadas para desde ações simples — como preencher células, formatar planilhas ou criar botões — até soluções mais avançadas, como consumo de APIs, integração com bancos de dados e execução de scripts externos.

Fonte: https://br.freepik.com/

No contexto deste artigo, as macros são o elemento central que possibilita transformar o LibreOffice Calc em uma ferramenta poderosa para análise de dados financeiros e integração com inteligência artificial, como o ChatGPT.

O LibreOffice oferece suporte nativo a diferentes linguagens de macro, sendo as principais:

• LibreOffice Basic (uma variação moderna do BASIC, fortemente integrada à API UNO) e

• Python (via ScriptForge, APSO e suporte nativo)

Este artigo apresenta uma visão geral da arquitetura de macros, conceitos fundamentais e boas práticas, preparando o terreno quem deseja entrar em detalhes mais específicos de Basic e Python.

A arquitetura de macros no LibreOffice

O LibreOffice é construído sobre a UNO (Universal Network Objects), uma arquitetura de componentes que permite que diferentes linguagens interajam com os mesmos serviços internos da suíte.

Isso significa que, independentemente de você usar Basic ou Python, no final das contas estará acessando os mesmos objetos:

• Documentos (Calc, Writer, Impress, etc.),

• Planilhas e células,

• Estilos,

• Menus, barras de ferramentas e

• Serviços como diálogo, arquivos, rede, entre outros.

A diferença está na linguagem, na ergonomia do código e no ecossistema de bibliotecas disponíveis.

De forma simplificada:

• O LibreOffice fornece a infraestrutura (UNO),

• As macros são clientes dessa infraestrutura e

• Basic e Python são apenas duas formas diferentes de conversar com os mesmos serviços.

Onde as macros ficam armazenadas

As macros no LibreOffice podem existir em três níveis principais:

Macros do usuário

Ficam disponíveis para todos os documentos do usuário atual.

• São ideais para funções reutilizáveis,

• Facilitam padronização e

• Podem ser versionadas externamente.

Normalmente ficam organizadas em:

• Minhas Macros

◦ LibreOffice Basic

◦ Python

Macros do documento

Ficam embutidas diretamente no arquivo (.ods, .odt, etc.).

• Viajam junto com o documento,

• Ideais para planilhas que serão distribuídas e

• Exigem atenção especial à segurança.

Macros da aplicação

Macros internas do LibreOffice.

Segurança e nível de confiança

Macros são código executável e, por isso, representam um risco potencial. O LibreOffice adota um modelo de segurança baseado em níveis de confiança:

• Macros desabilitadas,

• Macros habilitadas com confirmação e

• Macros sempre habilitadas (para locais confiáveis).

Para trabalhar com macros de forma produtiva, é altamente recomendável:

• Definir pastas confiáveis para seus projetos,

• Evitar habilitar macros indiscriminadamente e

• Separar ambientes de desenvolvimento e uso final.

A configuração padrão do LibreOffice é que macros estão desabilitadas.É necessário configurar de modo que permita a execução de macros. Então vá em Ferramentas -> Opções.

Clique em Segurança e em Segurança de macros. Selecione a segurança Média, a qual exibe uma caixa de diálogo pede a confirmação do usuário antes da execução do script. Daí é só confirmar.

Tela de Configuração de Segurança de Macros

O editor de macros

O LibreOffice fornece ferramentas diferentes dependendo da linguagem escolhida.

Editor de LibreOffice Basic

• Acessado via: Ferramentas → Macros → Organizar Macros → Basic,

• IDE simples, porém integrada,

• Depurador básico disponível e

• Forte integração com diálogos e formulários.

Editor de Python

• Suporte nativo a scripts Python,

• Integração com a extensão APSO (Alternative Python Script Organizer),

• Possibilidade de usar editores externos (VS Code, PyCharm, etc.).

O uso de Python permite maior produtividade, melhor organização de código e acesso a bibliotecas modernas, algo especialmente relevante quando lidamos com dados financeiros e APIs externas.

Organização de macros: pensando como um projeto

Um erro comum é tratar macros como pequenos trechos isolados de código. É fundamental que adotemos uma abordagem diferente: macros como projetos de software.

Boas práticas incluem:

• Separar lógica de negócio da interface,

• Criar módulos reutilizáveis,

• Usar nomes claros e consistentes e

• Documentar funções e parâmetros.

Mesmo em Basic, é possível (e recomendável) organizar macros em módulos com responsabilidades bem definidas.

Essa organização é essencial quando criamos macros sobre dados financeiros e integração com GPT, onde a complexidade cresce rapidamente.

Macros e automação financeira

No contexto financeiro, macros no LibreOffice permitem:

• Importar cotações de ativos,

• Atualizar dados automaticamente,

• Calcular indicadores,

• Criar relatórios dinâmicos e

• Integrar com APIs externas.

No entanto, existem limitações importantes:

• O ambiente de macro não é ideal para bibliotecas pesadas,

• Nem todas as dependências Python podem ser instaladas diretamente e

• Chamadas HTTP podem ser limitadas dependendo da linguagem.

Essas limitações explicam decisões arquiteturais, tais como o uso de scripts externos e comunicação entre processos.

Basic vs Python: quando usar cada um

Sem entrar ainda nos detalhes técnicos, algumas diretrizes gerais:

LibreOffice Basic:

• Excelente integração nativa,

• Curva de aprendizado menor para automações simples e

• Ideal para interação direta com o usuário (botões, diálogos).

Python:

• Código mais expressivo e legível,

• Ecossistema vasto (APIs, dados, IA) e

• Melhor manutenção a médio e longo prazo.

Considerações finais

Este artigo teve como objetivo criar uma base conceitual sólida sobre macros no LibreOffice, sem ainda mergulhar em código específico.

Se desejar ir mais a fundo nos detalhes e desafios da criação mesmo de macros tanto em Basic quanto em Python veja nosso e-book Dados Financeiros e ChatGPT com LibreOffice.

Ao longo do livro, você verá exemplos equivalentes em ambas as linguagens, permitindo comparar abordagens e tomar decisões técnicas mais conscientes.

Usando a biblioteca yfinance no LibreOffice Calc

2026-01-04T19:28:00.005-03:00

Usando a biblioteca yfinance no LibreOffice Calc

Já vimos no post anterior que LibreOffice oferece recursos para rodar macros em Python. Um biblioteca de ferramentas denominada ScriptForge busca simplificar o desenvolvimento dessas macros e a extensão APSO (Alternative Python Script Organizer) facilita ainda mais a criação e organização.

Fonte: https://br.freepik.com/

A interface de APSO oferece atualmente uma versão beta do Package manager, que se propõe a instalar e desinstalar pacotes pip. Todavia, esse recurso não funciona para todas bibliotecas, entre elas a yfinance. E é sobre isso que falaremos neste artigo, e como contornar essa dificuldade.

Antes de mais nada precisamos instalar a extensão APSO. Veja no post anterior como instalar e configurar o que precisamos na APSO.

Depois de instalada a extensão, vamos analisar as dificuldades encontradas. A primeira delas é que as macros Python no LibreOffice executam em seu próprio ambiente virtual. Se você clicar em Ferramentas -> Macros -> Organizar scripts em Python, em seguida no botão Menu e Python shell, verá que a versão do Python que executa é possivelmente diferente da versão que você tem no seu computador. Isso é um indício de que os ambientes são diferentes.

O ambiente de execução de scripts dentro de softwares de planilha — como o LibreOffice — é limitado, controlado e isolado. Ele foi pensado para automações simples, integração com a própria planilha e pequenas rotinas de apoio. Não foi projetado para rodar bibliotecas modernas de mercado financeiro, que dependem de camadas mais profundas do sistema operacional, extensões nativas e dependências externas.

Bibliotecas como o yfinance, por exemplo, utilizam componentes que exigem:

dependências compiladas
bibliotecas de baixo nível
controle preciso do ambiente Python

Forçar esse tipo de ferramenta a rodar dentro do ambiente interno da planilha gera uma cadeia de problemas: conflitos de versões, erros difíceis de diagnosticar, dependência do sistema do usuário e, principalmente, fragilidade.

A solução adotada neste artigo segue um princípio simples e poderoso: cada ferramenta deve fazer apenas o que ela faz melhor.

A planilha continua responsável por:

registrar dados
processar informações
apresentar visões claras
apoiar decisões

Já a coleta de dados externos — como cotações de mercado — acontece em um script Python independente, executado fora da planilha, em um ambiente controlado e previsível.

A comunicação entre esses dois mundos é feita de forma explícita, por meio da execução de um processo externo. A planilha pede a informação. O script busca, processa e devolve o resultado. Não há mágica, nem dependências invisíveis.

Essa separação, como se fossem duas camadas, traz vantagens importantes:

isolamento de erros
facilidade de manutenção
possibilidade de atualizar o script sem mexer na planilha
liberdade para usar bibliotecas modernas sem limitações

Resumindo, vamos escrever dois scripts. Um que executa em um ambiente Python no sistema do usuário. E a macro Python que executa no LibreOffice e chama o primeiro script por meio da biblioteca subprocess do Python.

A biblioteca subprocess é usada para gerenciar e interagir com processos externos (programas ou comandos do sistema operacional) diretamente do seu script Python. Ou seja, a macro Python na planilha vai chamar um comando do shell do sistema operacional, tal como Python script_externo.py, por exemplo.

Porém, antes de partirmos para a solução, precisamos falar das variáveis de ambiente PYTHONHOME e PYTHONPATH, usadas pelo interpretador Python para localizar módulos e bibliotecas, mas servem a propósitos distintos e, na maioria das vezes, não precisam ser configuradas manualmente, e geralmente não são mesmo.

Se você executar uma macro no LibreOffice que exibe essas variáveis, verá que PYTHONPATH retorna caminhos das bibliotecas que a própria ferramenta utiliza para executar seus scripts, ou seja, o LibreOffice seta essas variáveis globalmente. Desse modo, essas variáveis vazam para o script externo quando o executamos via subprocess.

Então vamos à nossa solução.

Primeiro passo

No shell do seu sistema, digite os seguintes comandos para criar uma pasta, um ambiente virtual e instalar as bibliotecas que serão usadas no script externo:

mkdir external_scripts
cd external_scripts
python3 -m venv .venv
source .venv/bin/activate
pip install yfinance

Segundo passo

Crie o script externo denominado price.py, por exemplo. Neste exemplo, o script espera um argumento, o qual deve ser um ticker (código da empresa na bolsa) válido e usa o yfinance para buscar o último preço desse ativo.

import sys
import yfinance as yf

ticker = sys.argv[1]
price = yf.Ticker(ticker).history(period="1d")["Close"].iloc[-1]
print(price)

Terceiro passo

Crie a macro Python no LibreOffice Calc.

import subprocess
import os


def update_price():
    env = os.environ.copy()

    # REMOVE as variáveis de ambiente do LibreOffice
    env.pop("PYTHONHOME", None)
    env.pop("PYTHONPATH", None)
    
    # Define o comando "python price.py PETR3.SA"
    cmd = [
        "/home/carlos/external_scripts/.venv/bin/python",
        "/home/carlos/external_scripts/price.py",
        "PETR3.SA"
    ]
    
    # Executa o comando no shell e captura o resultado (python price.py PETR3.SA)
    # Aqui é necessário tratar exceções
    result = subprocess.run(cmd, capture_output=True, text=True, env=env)
    price = float(result.stdout.strip())

    # Escreve o preço na célula A1
    doc = XSCRIPTCONTEXT.getDocument()
    sheet = doc.CurrentController.ActiveSheet
    sheet.getCellByPosition(0, 0).Value = price

Observe que removemos as variáveis de ambiente antes de executar o script externo. No list cmd informamos exatamente o caminho do comando python, o caminho do script price.py e o argumento.

O subprocess retorna um objeto, do qual nos interessa stdout, que é o que foi exibido na saída padrão. Esse valor é uma string, que é convertido para float e exibido na célula A1. A exibição usa os recursos de macros da LibreOffice, tais como XSCRIPTCONTEXT, uma interface fornecida aos scripts que oferece um meio de acesso às diversas interfaces que eles podem precisar para executar alguma ação em um documento.

Conclusão

Esta é uma solução que roda exclusivamente na máquina local do usuário. Uma outra opção, que depende de outros recursos, é criar uma API REST que tem um endpoint para acesso à yfinance. E a macro usaria requests para fazer uma requisição a essa API.

Se você tem interesse em outras soluções de macros em Basic ou Python para LibreOffice dê uma olhada em https://stonefull.gumroad.com/l/financial_data_chatgpt_libreoffice.

Integrando Python e ChatGPT com LibreOffice Calc

2025-12-16T18:51:00.009-03:00

Integrando Python e ChatGPT com LibreOffice Calc

O Excel agora permite executar scripts Python dentro de uma célula, simplesmente usando a fórmula =PY. No entanto, essa é uma funcionalidade disponível apenas nas licenças pagas. O LibreOffice é um pacote para escritórios, a exemplo do Office da Microsoft, todavia livre e de código aberto. Ele tem planilha, editor de textos, editor de apresentação e muitas outras aplicações. E ainda roda em vários sistemas operacionais, incluindo Linux.

Se você prefere usar ferramentas gratuitas e ainda assim não abrir mão de recursos tais como rodar scripts Python numa célula de planilha, este artigo pode lhe interessar.

Neste post iremos apresentar a LibrePythonista, uma extensão para LibreOffice que nos habilita usar Python dentro de uma planilha Calc, possibilitando que utlizemos a biblioteca pandas, por exemplo, e assim, analisar dados usando um DataFrame. Dado que podemos instalar qualquer biblioteca com essa extensão, iremos instalar e usar a openai, para acessar o ChatGPT e criar conteúdo usando IA.

Tela do LibreOffice Calc com Python

Pré-requisitos

LibreOffice e Python instalados. Tudo vai rodar no seu PC. Não vamos abordar essas instalações aqui.

Iremos tratar apenas da instalação e configuração da extensão LibrePythonista.

Precisamos também das bibliotecas python-dotenv e openai, as quais mostraremos mais adiante como instalá-las.

Instalando a extensão

Inicialmente, acesse o repositório de extensões do LibreOffice, digite LibrePythonista na caixa de pesquisa e clique no botão Search. Você verá esta tela:

Tela de https://extensions.libreoffice.org/

Clique no card da biblioteca e em seguida no botão Download latest. Agora abra o Calc e vá em Ferramentas -> Extensões. Você verá uma janela com as extensões instaladas. Clique em Adicionar e procure o arquivo LibrePythonista.oxt na pasta de downloadas do seu computador. Aceite a licença e quando a instalação finalizar concorde em reiniciar o Calc. Agora você verá o menu LibrePy. Nesse processo de instalação, alguns pacotes são instalados por padrão: pandas e matplotlib, por exemplo.

O último passo antes de ver a extensão em ação é configurar a segurança de macros. É necessário configurar de modo que o Calc permita a execução de macros. O padrão é que não execute. Então vá em Ferramentas -> Opções.

Tela de configutação de segurança de macros

O primeiro script

Com o propósito de ver se está tudo certo. Digite, por exemplo, 10 na célula A1, 20 na célula B1 e, com C1 selecionada, clique no menu LibrePy -> Inserir Python. Ou use o atalho SHIFT+CTRL+ALT+L. Um botão será inserido em C1, indicando que esta célula tem script Python.

Clique no botão dentro da célula e em Editar Código e o editor irá abrir. Digite o código que aparece na imagem e clique em OK. O resultado será exibido na célula C1. A função lp() pega o valor de uma célula e o atribui a uma variável. O restante do script é Python, sendo que na última linha digitamos a variável que será exibida na célula. Quando salvamos a planilha, o script é salvo também.

Pronto. A extensão está instalada, configurada e funcionando. Mas o que queremos é utilizar o Calc como nossa ferramenta para controle de finanças pesoais, a exemplo que temos feito com Google Sheets. Mais especificamente, queremos acessar o ChatGPT a partir de uma célula a fim de registrar transações e de obter diagnóstico e insights sobre nossas finanças.

Acessando o ChatGPT

A primeira providencia a tomar a fim de ter acesso à IA é guardar o token da API da OpenAI em lugar seguro. E temos duas opções:

Criar uma variável de ambiente no sistema operacional e manter aí o token. O procedimento para isso depende do sistema onde o LibreOffice está executando.
Utiizar a biblioteca python-dotenv, conforme já mostramos neste artigo. Neste caso, precisamos manter a chave da API num arquivo denominado .env.

Vamos adotar a segunda opção, a qual funciona em qualquer sistema operacional. Para isso, crie o arquivo .env com a chave OPENAI_API_KEY=sua_chave_da_API_OpenAI, por exemplo, e salve-o em uma pasta apropriada. Eu salvei no mesmo diretório onde salvei a planilha.

Na planilha, eu quero solicitar ao ChatGPT que leia uma frase que está na célula A1, interprete e extraia dados de uma transação financeira e retorne um JSON com esses dados. O script estará na célula B1.

Para isso, nós precisamos de duas bibliotecas externas: python-dotenv, reponsável para ler variáveis de ambiente, no caso OPEN_API_KEY, e openai, para acesso a modelos de IA da OpenAI.

A fim de instalar esses pacotes, abra o menu LibrePy -> Pip -> Instalar pacote Pip. Na janela que será aberta digite o nome do pacote, python-dotenv, e clique em OK. Repita o procedimento para instalar o pacote openai.

Agora selecione a célula B1 e clique no menu LibrePy -> Inserir Python. Ou use o atalho SHIFT+CTRL+ALT+L. O controle será exibido na célula, indicando que ela contém um script Python. clique no controle e em Editar Código. Digite o código no editor:

import os
import json
from openai import OpenAI
from dotenv import load_dotenv
from datetime import date

load_dotenv(dotenv_path = "/home/carlos/development/libreoffice-com-ia/.env")

API_KEY = os.getenv("OPENAI_API_KEY")

client = OpenAI(api_key=API_KEY)

mensagem = lp("A1")

response = client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=[
                {
                    "role": "system",
                    "content": """Você é um sistema de categorização de
                        transações financeiras. Responda APENAS em formato
                        JSON válido, sem explicações adicionais."""
                },
                {
                    "role": "user",
                    "content": f"""Extraia da frase abaixo:
                        - valor (float, usar . como separador decimal)
                        - tipo: "Receita" ou "Despesa"
                        - categoria (uma palavra)
                        - data (DD/MM/YYYY; se não informado,
                            usar {date.today().strftime("%d/%m/%Y")})

                    Frase: "{mensagem}"

                    Retorne APENAS JSON, exemplo:
                        {{"valor": 58,.0, "tipo": "Despesa",
                            "categoria": "Alimentacao",
                            "data": "28/11/2025"}}"""
                }
            ],
            max_tokens=800,
            temperature=0.3)
texto = response.choices[0].message.content.strip()
texto

Inicialmente importamos as bibliotecas necessárias, e em seguida carregamos o arquivo .env informando o caminho absoluto na função load_dotenv(). Assegure-se de informar o caminho correto para o seu arquivo .env. Feito isso, lemos o token e inicializamos um cliente OpenAI. Depois, a frase é lida da célula A1. Estamos utilizando o mesmo prompt já usado em artigos passados para chamar o método chat.completions.create().

A chamada retorna um response, e o conteúdo mesmo da resposta é extraido para a variável texto. Daí temos um json exibido na célula em formato string. Observe que na caixa de entrada referente à célula com o código Python, há a seguinte fórmula: =PY.C(PLANILHA();CÉL("ADDRESS"); A1). O último parâmetro indica uma célula ou intervalo, o qual dispara a execução do script, caso seja modificado. Assim, informamos A1 neste caso.

Nosso objetivo é preencher cada célula subsequente, na mesma linha, com os valores retornados no json. Entretanto, não vimos, na extensão LibrePythonista, uma maneira de o script preencher células diferentes daquela onde o script está executando. Por esse motivo, iremos partir para uma solução alternativa.

Insira Python na célula C1 e digite o seguinte código:

import json

texto = lp("B1")
texto_json = json.loads(texto)

valor = texto_json["valor"]
valor

O que fazemos aqui é pegar o conteúdo de B1 (resposta da IA) e exibir valor na célula. Defina a fórmula na caixa de entrada como =PY.C(PLANILHA();CÉL("ADDRESS");B1), de modo que C1 seja atualizada sempre que B1 se modificar. Repita isso para categoria e tipo nas células D1 e E1, respectivamente. Finalmente, podemos ocultar a coluna B1.

Outra limitação com a qual me deparei é que ao copiar uma célula para outra, o script não é copiado. Então, temos que repetir todo esse processo nas demais linhas.

Solução alternativa usando Python com ScriptForge

Essa parte final, onde os valores do json são escritos nas células seguintes, pode ser feita com uma macro Python usando ScriptForge, a qual é uma biblioteca de ferramentas que simplifica o desenvolvimento de macros e scripts em Python e LibreOffice Basic.

Vamos instalar a extensão APSO (Alternative Python Script Organizer), que simplifica um pouco mais a criação e organização das macros Python. O processo de instalação é o mesmo que fizemos para instalar a LibrePythonista.

Antes de prosseguir é recomendado configurar o editor de sua preferência. Vá em Ferramentas -> Extensões. Clique na extensão APSO e em Opções. Digite o caminho completo do editor na caixa de texto ou clique no botão Escolher para selecionar pelo navegador de pastas. Com isso, o menu Editar na janela do APSO irá abrir o editor que você definiu.

Outro ponto a se preocupar é onde as macros serão salvas. Em geral, o LibreOffice procura as macros em um diretório no perfil do usuário:

No Windows: %appdata%\libreoffice\4\user\scripts\python
No Linux: ~/.config/libreoffice/4/user/scripts/python

Se as pastas scripts e python não existirem, você precisa criá-las.

Agora, vá em Ferramentas -> Macros -> Organizar scripts em Python. Esta janela será aberta:

Tela do APSO

Com Minhas Macros selecionada, clique em Menu e Criar Módulo. Informe um nome para o módulo. Por exemplo minhas_macros.py e confirme. Agora, clique no nome do módulo e em Menu -> Editar. Digite este código no arquivo criado:

import json
from scriptforge import CreateScriptService

doc = CreateScriptService("Calc")

def fill_cells(args=None):
    value = doc.GetValue("B1")
    texto_json = json.loads(value)

    doc.SetValue("F1", texto_json["valor"])
    doc.SetValue("G1", texto_json["categoria"])
    doc.SetValue("H1", texto_json["tipo"])

g_exportedScripts = (fill_cells, )

Após os imports necessários, o primeiro passo é definir que estaremos lidando com uma planilha do Calc. Em seguida definimos uma função denominada fill_cells(). Ela irá aparecer na janela do APSO e dará a opção de ser executada.

Depois, o valor retornado pelo ChatGPT é lido e convertido em json. E cada um dos campos é escrito numa célula.

Finalmente, nós exportamos as funções que serão nossos scripts a ser executados. Note que, na imagem da janela do APSO, fill_cells aparece abaixo de arquivo, que foi o nome que dei ao meu módulo. Note também que, se você clicar em fill_cells, o botão Executar é habilitado. Clique nele para rodar o script. E, pronto, os valores preenchem as células F1, G1 e H1, conforme programamos no script.

Conclusão

A extensão LibrePythonista ainda está em beta. Possui muitas limitações. No entanto, podemos nos beneficiar do uso de IA para tarefas mais esporádicas, tais como analisar uma planilha de finanças pessoais e nos dar alguns insights que podem nos ajudar a economizar e usar mais racionalmente o nosso dinheiro.

Alternativamente, podemos criar esse script usando ScriptForge e Python. O uso de pacotes externos pode ser um desafio, mas está em beta na extensão APSO a opção de gerenciar pacotes pip, o que pode ser de grande ajuda. No entanto, apesar das limitações, LibrePythonista oferece uma fórmula que possibilita que o script seja executado sempre que uma célula ou intervalo de células seja modificado. A execução de scripts ScriptForge com Python a partir de atualizações de células parece ser bastante desafiador.

De todo modo, num próximo post, iremos tratar como fazer esta integração usando ScriptForge e Python.

Se você tem interesse em outras soluções de macros em Basic ou Python para LibreOffice dê uma olhada em https://stonefull.gumroad.com/l/financial_data_chatgpt_libreoffice.

Como Integrar ChatGPT com Google Sheets usando Google Apps Script

2025-12-12T19:02:00.001-03:00

Como Integrar ChatGPT com Google Sheets usando Google Apps Script

Vimos no post anterior como integrar ChatGPT com Google Sheets utilizando uma extensão. Ao usar uma extensão ficamos limitados às funções que a ferramenta oferece, e isso pode não ser o melhor dos mundos ao criar uma planilha.

Neste artigo iremos introduzir uma alternativa ao uso de extensões. Vamos programar nossas próprias funções, adequando-as às nossas necessidades. Para isso usaremos o Apps Script, uma plataforma JavaScript baseada na nuvem com a tecnologia Google Drive que permite integração e automação de tarefas nos produtos do Google, não apenas no Sheets.

Fonte: https://br.freepik.com/

Pré-requisitos

Será necessário que você tenha um token da API OpenAI. Neste artigo nós mostramos como obtê-lo. Reforçando que o uso desta API tem um custo e devemos estar cientes disso.

É necessário conhecimento de JavaScript. Não está no escopo deste post introduzir o leitor nesta linguagem. Se for necessário estudar os fundamentos de JavaScript, recomendo o tutorial da W3School.

O que será criado

Vamos criar uma função personalizada no Google Sheets, que usa o ChatGPT para extrair dados de uma transação informada pelo usuário na forma textual. Por exemplo: 98 reais remédios. Essa frase será digitada na coluna Descrição. E o script criado por nós estará numa opção de menu, e ao ser executado, irá analisar a frase e preencher as demais colunas da linha: Data, Valor, Categoria e Tipo.

Primeiro passo

Inicialmente crie uma planilha com as seguintes colunas: Descrição, Data, Valor, Categoria e Tipo. Nomeie a planilha como Finanças Pessoais e a página como Transações, por exemplo. Você pode atribuir qualquer nome. Em seguida clique no item de menu Extensões -> Apps Script. Será aberta uma nova aba no navegador com esta aparência:

Tela do Projeto Apps Script vinculado à planilha

Clique em Projeto sem título e renomeie-o. Por exemplo, pode dar o nome de ChatGPT for Sheets. E agora estamos prontos para criar nossa função. No entanto, antes de começar, vamos inserir o token da API OpenAI. Para isso, clique na engrenagem à esquerda: Configurações do projeto. Role a tela até encontrar Propriedades do script e clique em Adicionar propriedade do script.

Tela para adicionar propriedade

Digite o nome da propriedade na caixa Propriedade: API_TOKEN, por exemplo, e cole o token na caixa Valor. Agora, clique no botão Salvar propriedades do script. Com isso, nós evitamos expor o token no código do script, o que é uma prática recomendada. Para retornar ao script, clique no ícone Editor à esquerda.

Segundo passo

A seguir vamos iniciar a criação do script, explicando o conceito de namespace. Namespace, no contexto de linguagens de programação, é um espaço nomeado onde podemos declarar variáveis, objetos, classes, funções, etc., os quais estão fora do escopo global. Para acessar qualquer desses elementos precisamos utilizar primeiro o nome do espaço, seguido do identificador do elemento. Estamos usando esse recurso para prevenir que funções internas ao script sejam acessadas em uma célula da planilha.

Antes de digitar qualquer linha de código, delete as linhas existentes no editor e digite o seguinte trecho. Esse é o código da função que lê o token da API armazenado nas propriedades do script:

const Utils = {
  getApiKey: function() {
    var scriptProperties = PropertiesService.getScriptProperties();
    var apiKey = scriptProperties.getProperty('API_TOKEN');
    return apiKey;
  }
}

Aqui definimos Utils como um namespace e escrevemos as funções que desejamos sejam privadas dentro desse espaço. Namespace é um objeto JavaScript, onde cada elemento é definido na forma chave/valor. Neste caso, getApiKey é a chave, e o valor é a declaração da função. Basicamente, estamos usando a classe PropertiesService para obter o valor da propriedade API_TOKEN, que definimos anteriormente. Além de ler uma propriedade, esta classe também pode gravar novas propriedades, mas isso não nos interessa agora.

Em seguida, escrevemos a função que faz a requisição à API da OpenAI, dentro do namespace. Esta função recebe o prompt do sistema e do usuário, faz a requisição e retorna a mensagem respondida pelo modelo. Assim, você pode criar depois outras funções customizadas, além desta que analisa o texto da transação. Apenas defina os prompts e chame getResponseAI().

const Utils = {
  getApiKey: function() {
    var scriptProperties = PropertiesService.getScriptProperties();
    var apiKey = scriptProperties.getProperty('API_TOKEN');
    return apiKey;
  },

  getResponseAI: function(system_prompt,user_prompt) {
    var requestOptions = {
      "method": 'POST',
      "headers": {
        "Content-Type": "application/json",
        "Authorization": `Bearer ${Utils.getApiKey()}`
      },
      "payload": JSON.stringify({
        "model": 'gpt-4.1',
        "input": user_prompt,
        "instructions": system_prompt,
        "max_output_tokens":500
      })
    };

    var response = UrlFetchApp.fetch("https://api.openai.com/v1/responses", requestOptions);
    if (response.getResponseCode() !== 200) {
      Logger.log(response.getContentText());
      throw new Error("Falha na requisição à IA: " + response.getContentText());
    }
    
    response = JSON.parse(response);

    return response.output[0].content[0].text;
  }
}

Note que, antes de iniciar a nova função, foi inserida uma vírgula após o elemento anterior. Isso é parte da sintaxe do objeto JavaScript.

Diferente do que vimos no artigo Seu Assistente Financeiro Pessoal no Telegram: Integrando IA ao Bot do Google Sheets, onde usamos uma biblioteca Python para acessar a API OpenAI, aqui não temos intermediário. A requisição (fetch) é feita diretamente ao endpoint da API, informando as opções da requisição, de acordo com as instruções da documentação.

Função personalizada

Mesmo não sendo a solução que iremos adotar neste exemplo, vamos apresentar uma função personalizada que interpreta a frase e retorna os valores da transação: Data, Valor, Categoria e Tipo.

/**
 * Interpreta uma transação em forma textual.
 * @customfunction
*/
function INTERPRETAR(text) {
  if (text === null || text === "") {
    return [[]];
  }
  var system_prompt = 'Você é um sistema de categorização de transações financeiras. Responda APENAS em formato JSON válido, sem explicações adicionais.';
  var user_prompt = `Extraia da frase abaixo:
                        - valor (float, usar . como separador decimal)
                        - tipo: "Receita" ou "Despesa"
                        - categoria (uma palavra)
                        - data (DD/MM/YYYY; se não informado,
                           usar ${new Date()})

                    Frase: ${text}

                    Retorne APENAS JSON, exemplo:
                        {{"valor": 58,.0, "tipo": "Despesa",
                            "categoria": "Alimentacao",
                            "data": "28/11/2025"}}`;
  json_response = JSON.parse(Utils.getResponseAI(system_prompt, user_prompt));
  return [[json_response.data, json_response.valor, json_response.categoria, json_response.tipo]];
}

A função INTERPRETAR() fica após o namespace Utils. Ou seja, fora do escopo do namespace. Uma função personalizada precisa ter a anotação @customfunction a fim de que apareça na complementação quando digitamos = numa célula. Mas não é obrigatório. Bem como não é obrigatório que nome da função esteja em caixa alta. Apenas seguimos o padrão de nomes das funções.

Se o retorno de uma função customizada for um único valor, este é lançado na célula corrente. Se for um array, os valores deste são lançados na coluna a partir da célula corrente. Se retornar um array de arrays, então um trecho de tabela é lançado a partir da célula corrente, onde cada elemento array compõe uma linha.

No nosso caso queremos lançar os dados da transação a partir da coluna Data, por isso retornamos um array de array. Logo no início da função INTERPRETAR(), que recebe como parâmetro o nome da célula onde está a frase, é verificado se o conteúdo dessa célula é vazio. Caso seja, a função retorna um array de array vazio.

Em seguida são criados os prompts, tanto de sistema quanto de usuário, e estes são passados para Utils.getResponseAI(), a qual retorna um JSON, de acordo com as instruções nos prompts.

E porque não adotamos essa função como solução para o nosso problema? Dois motivos são determinantes:

Sempre que a planilha é atualizada, a função INTERPRETAR() é executada, do mesmo modo que ocorre com qualquer fórmula ou operação. Com isso, é feita uma requisição à API, gerando um custo desnecessário.
Outro inconveniente, decorrente da atualização, é que a Data da transação, caso não seja informada na frase, é definida como a data corrente, conforme nossas instruções nos prompts. Dessa forma, depois de uma atualização, todas as transações passam a ter a data corrente e deixam de ter a data dos seus respectivos lançamentos.

Devido a esses motivos, optamos por criar um menu personalizado e um item de menu que chama a função que fará a interpretação.

Menu personalizado

Um menu personalizado é adicionado ao menu padrão do Google Sheets, ou de outra ferramenta do Google, utilizando a função onOpen(), que define alguma ação que ocorre ao abrir uma planilha ou documento. Nessa função é criado o menu IA Financeira e o item Processar Frase Selecionada. O mesmo método que cria o item recebe o nome de uma função a ser executada, no caso processarFraseIA.

function onOpen() {
  SpreadsheetApp.getUi()
    .createMenu('IA Financeira')
    .addItem('Processar Frase Selecionada', 'processarFraseIA')
    .addToUi();
}

function processarFraseIA() {
  const sheet = SpreadsheetApp.getActiveSheet();
  const cell = sheet.getActiveCell();
  const text = cell.getValue();

  if (!text || typeof text !== 'string') {
    SpreadsheetApp.getUi().alert("Selecione uma célula com uma frase.");
    return;
  }

  const dados = interpretar(text);

  const row = cell.getRow();
  const col = cell.getColumn();

  // Grava dados nas células seguintes
  sheet.getRange(row, col + 1).setValue(dados.data);
  sheet.getRange(row, col + 2).setValue(dados.valor);
  sheet.getRange(row, col + 3).setValue(dados.categoria);
  sheet.getRange(row, col + 4).setValue(dados.tipo);
  
  SpreadsheetApp.getUi().alert("Transação registrada!");
}

function interpretar(text) {
  var system_prompt = 'Você é um sistema de categorização de transações financeiras. Responda APENAS em formato JSON válido, sem explicações adicionais.';
  var user_prompt = `Extraia da frase abaixo:
                        - valor (float, usar . como separador decimal)
                        - tipo: "Receita" ou "Despesa"
                        - categoria (uma palavra)
                        - data (DD/MM/YYYY; se não informado,
                           usar ${new Date()})

                    Frase: ${text}

                    Retorne APENAS JSON, exemplo:
                        {{"valor": 58,.0, "tipo": "Despesa",
                            "categoria": "Alimentacao",
                            "data": "28/11/2025"}}`;
  json_response = JSON.parse(Utils.getResponseAI(system_prompt, user_prompt));
  return json_response;
}

A função processarFraseIA() espera que a célula selecionada contenha a frase a ser analisada. Então ela verifica a existência da frase e chama a função interpretar(). Esta irá retornar um JSON, cujos dados são lançados nas células seguintes à direita da célula corrente.

Assim, você deve passar a ter um novo menu na sua planilha, como mostra a imagem:

Tela da planilha com o menu personalizado

Agora, digite a frase na coluna A, por exemplo, e clique no menu IA Financeira -> Processar Frase Selecionada. Os dados extraídos serão inseridos nas células à direita.

Conclusão

Apps Script nos oferece inúmeras possibilidades de criar planilhas poderosas para ajudar nosso controle das finanças pessoais. Mas deve ser usado com cautela, principalmente devido a questões relacionadas à segurança.

Apps Script pede permissão para acessar seus dados de Google Sheets, Google Drive, etc. Conceda apenas a permissão mínima necessária.

Evite copiar códigos de terceiros na Web. Eles podem fazer acesso aos seus dados, arquivos. Confie apenas em fontes verificadas.

Não exponha senhas, chaves de API, etc. no seu código. Procure guardá-los de forma segura, preferencialmente criptografados.

ChatGPT + Google Sheets: a combinação perfeita para controlar seus gastos automaticamente

2025-12-09T18:34:00.003-03:00

ChatGPT + Google Sheets: a combinação perfeita para controlar seus gastos automaticamente

Controlar seus gastos no dia a dia nem sempre é uma tarefa simples. Em posts anteriores nós aprendemos como integrar o Python ao Google Sheets, e até vimos como criar um bot Telegram que interage com uma planilha via mensagens e comandos. Nessas estratégias, o usuário quase não precisa manipular a planilha diretamente. Mas combinar ChatGPT com Google Sheets pode tornar tudo automático, rápido e bem mais intuitivo.

Neste post, você vai aprender passo a passo como montar um sistema de controle financeiro automático usando essas duas ferramentas. Essa integração se dá pela utilização de extensões do Google Sheets ou scripts, criados com Apps Script, que se conectam à API da OpenAI.

Apps Script é uma plataforma Javascript baseada em nuvem que permite a integração e automação de tarefas nos produtos do Google, e que requer escrever código. Já as extensões adicionam novas fórmulas ao conjunto existente do Google Sheets. Essas fórmulas, tais como =GPT(), por exemplo, possibilitam o envio de prompts a um modelo selecionado.

Fonte: https://br.freepik.com/

Benefícios de usar ChatGPT + Google Sheets

O ChatGPT permite interpretar linguagem natural — ou seja, você pode “conversar” com sua planilha, pedir para ela classificar despesas por categoria (alimentação, transporte, lazer etc.), corrigir fórmulas ou gerar resumos e insights.
O Google Sheets oferece flexibilidade, armazenamento na nuvem e liberdade para customizar colunas, categorias, relatórios mensais.
Escolhendo a integração certa, você reduz drasticamente o trabalho manual de digitar cada transação financeira, categorizar e conferir totais.

Extensões que podem ser usadas

A fim de usar o ChatGPT integrado ao Google Sheets ou criar automações com ele, podemos citar algumas opções:

GPT for Sheets and Docs possibilita selecionar dentre algumas IAs (ChatGPT, Claude, Gemini, entre outras). Funciona tanto no Sheets quando no Docs e é voltado para operações em grande volume de dados. Período de teste gratuito.
ChatGPT para Google Slides, Sheets e Docs é baseado em OpenAI e Gemini. Uso gratuito com alguns recursos premium pagos.
Easy GPT for Sheets: limitado apenas a GPT e gratuito. É necessário inserir o token da API OpenAI, ou seja, a extensão irá consumir seus créditos. Não é atualizada desde setembro de 2024. Mas pode ser uma opção para quem quer entrar nesse universo e experimentar o recurso. Depois pode escolher uma outra extensão ou até mesmo se aventurar no Apps Script.

Existem muitas outras alternativas, inclusive você pode usar o Gemini. Há um botão no canto superior direito quando você abre uma planilha denominado Teste o Gemini, que lhe dá acesso à ferramemta. Período de teste gratuito.

Exemplo prático: montando sua planilha

Aqui vai um passo a passo, considerando que você quer registrar suas despesas mensais, obter um relatório e eventualmente pedir à IA que faça algum diagnóstico e lhe dê insights sobre sua situação financeira.

1. Instale a extensão de sua preferência. Para este exemplo nós instalamos a Easy GPT for Sheets. Com Google Sheets aberto no navegador, clique no menu Extensões -> Complementos -> Instalar complementos. Na janela que será aberta, digite na caixa Pesquisar aplicativos: Easy GPT for Sheets. Diversas opções de aplicativos serão exibidas e você clica no primeiro card. A página da extensão será exibida e você clica em Instalar. Após a instalação, você clica de novo no menu Extensões e Easy GPT for Sheets será um dos itens do menu. Clique então na opção Configure e informe o seu token da API OpenAI. Role a tela até encontrar o botão Save Configuration e clique nele. Note que existe um botão para habilitar/desabilitar a extensão: Activate/Deactivate Add-on. Isso pode ser importante para não consumir seus créditos durante a criação da planilha.

2. Crie sua planilha, com colunas como: Data, Descrição, Valor, Categoria, Tipo. Vamos denominar essa planilha como Transações, por exemplo.

3. Crie fórmulas de IA para registrar a transação automaticamente. Vamos digitar uma transação na coluna Descrição (B2), por exemplo: "Paguei 50 reais no almoço". E vamos criar fórmulas de IA para extrair os dados, como Data, Valor, Categoria e Tipo. Na coluna Categoria (C2) digite:

=GPT("Você é um sistema de categorização de transações financeiras. Classifique a despesa descrita em: '" & $B2 & "' Classifique apenas como Alimentacao, Remedios, Lazer, Limpeza, Outros")

Assim, o ChatGPT irá extrair da nossa descrição uma categoria que se enquadre numa das opções fornecidas no prompt da fórmula. Você pode relacionar mais categorias, de acordo com sua necessidade. Em seguida copie essa fórmula para as demais células da coluna B.

Na coluna Data (A2) digite:

=GPT("Você é um sistema de interpretação e categorização de transações financeiras. Extraia a data da frase: '" & $B2 & "'. Se não houver nenhuma data, retorne exatamente este texto: '" & TEXTO(HOJE(); "dd/mm/yyyy") & "'. Não invente data e não altere o formato." )

Este prompt pede à IA que retorne a data, se houver na descrição. Ou retorne a data corrente, caso contrário.

Na coluna Valor (D2) digite:

=VALOR(GPT("Você é um sistema de interpretação e categorização de transações financeiras. Extraia da frase: '" & $B2 & "' o valor float. Use , como separador decimal"))

Finalmente, na coluna Tipo (E2) digite:

=GPT("Você é um sistema de interpretação e categorização de transações financeiras. Classifique a transação descrita em: '" & $B2 & "' Classifique apenas como Receita ou Despesa")

Estando essas fórmulas replicadas nas demais linhas e colunas, nós só precisamos digitar a descrição da transação na célula correspondente da coluna B. Você pode experimentar formatos variados de descrição para ver a IA em ação.

4. Crie a aba Dashboard. Use fórmulas do Google Sheets para totalizar gastos por categorias, gerar gráficos etc. Por exemplo: Na célula A2 desta aba digite a fórmula que totaliza gastos por categoria:

=QUERY('Transações'!C3:D24; "SELECT C, SUM(D) GROUP BY C LABEL SUM(D) 'Total por Categoria'"; 1)

Estamos considerando que a última linha da tabela Transações é a 24.

5. Use o ChatGPT para analisar seus gastos e gerar insights. Por exemplo, na aba Dashboard, escolha uma célula livre e digite:

=GPT("Aqui estão as transações do mês (colunas separadas por -, linhas por ponto e vírgula): '" & JOIN(";"; ARRAYFORMULA('Transações'!A2:A24 & "-" & 'Transações'!B2:B24 & "-" & 'Transações'!C2:C24 & "-" & 'Transações'!D2:D24 & "-" & 'Transações'!E2:E24)) & "'. Analise os 3 maiores gastos e recomende ajustes.")

Nesse prompt nós criamos uma string formada pelas linhas de Transações utilizando ARRAYFORMULA, que cria uma string com o valor de cada célula separado por um delimitador. No caso usamos - (hifen) visto que os valores numéricos usam vírgula como separador decimal. Esse resultado é passado para JOIN criar nova string juntando todas as linhas, agora separadas por ponto e vírgula. Esses dados nós enviamos no prompt, esclarecendo ao ChatGPT quais são os delimitadores, e pedimos ao modelo uma análise.

Incremente o Dashboard com outros resumos e gráficos. Adeque às suas necessidades.

Conclusão

Adotando essa estratégia de controle de suas finanças:

Você ganha clareza real sobre seus gastos — por categoria, por mês, com visualizações e resumos automáticos.
Reduz o esforço e minimiza a chance de erro na hora de classificar e organizar despesas.
Com a automação, você cria um hábito financeiro mais consistente — essencial para quem luta para manter o controle no dia a dia.

Melhorando seu Assistente Financeiro Pessoal: Registre Despesas usando IA

2025-12-02T15:41:00.006-03:00

Melhorando Seu Assistente Financeiro Pessoal: Registre Despesas usando IA

Tempo de leitura: 7 minutos

Criamos um Bot Telegram com o objetivo de ser nosso assistente financeiro pessoal nessa tarefa de gerenciar nosso dinheiro. Até então, ele aceita comandos para registrar despesas e receitas, listar os últimos registros e até fazer um diagnóstico e nos oferecer insights para melhorar a gestão do nosso dinheiro. Se você não acompanhou, pode voltar aos posts:

Como criar um bot no Telegram para atualizar uma planilha no Google Sheets e

Como integrar IA ao Bot para atuar como um assistente financeiro.

Neste artigo vamos implementar uma funcionalidade que vai facilitar ainda mais nossa tarefa. Vamos enviar uma mensagem informando o valor da transação e a que se refere esse valor. A Inteligência Artificial irá então analisar a mensagem e inferir uma transação a ser lançada na planilha. Dessa maneira não se faz necessário fazermos um registro de transação estruturada como exige o comando /save.

Fonte: https://br.freepik.com/

Pré-requisitos

Neste artigo iremos adicionar mais uma função de automação financeira ao nosso Bot, a qual usa IA para ler uma mensagem, de onde irá extrair os dados de uma transação e adicionar em nossa planilha de finanças pessoais.

Para isso, será necessário que você tenha lido os posts anteriores e, preferencialmente, clonado o repositório GitHub onde está o código do Bot.

Não será necessário instalar nenhuma nova biblioteca, pois iremos apenas precisar de json, que é embutida no Python e uma nova classe do pacote telegram, a MessageHandler. No mais, tudo que já instalamos até o momento será usado.

O que vamos criar

Até então, nosso assistente financeiro responde a comandos previamente programados: start, save, help, list e diagnostic. Agora queremos que a interação seja mais natural, sem necessidade de enviar mensagens estruturadas. Ou seja, queremos enviar uma mensagem do tipo "gastei 80 no almoço", "almoço 80", e a IA irá extrair dessa mensagem um registro que será efetivado na planilha financeira do Google Sheets.

A nova função

No código do Bot apresentado ao final deste post, acrescente as novas linhas conforme mostrado a seguir:

from dotenv import load_dotenv
# Acrescentar este import
import json
import os
import logging
import pandas as pd
from datetime import date
from utils import (
    conectar_google_sheets,
    normalizar_string,
    validar_chat_id)
from telegram import Update
from telegram.ext import (
    ApplicationBuilder,
    CommandHandler,
    ContextTypes,
# Acrescentar este import
    MessageHandler,
    filters)
from openai import OpenAI

# Restante do código igual ao do post anterior

# Acrescentar esta função
async def interpretar(update, context):
    mensagem = update.message.text

    # Chama IA para extrair informação
    try:
        resposta = client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=[
                {
                    "role": "system",
                    "content": """Você é um sistema de categorização de
                        transações financeiras. Responda APENAS em formato
                        JSON válido, sem explicações adicionais."""
                },
                {
                    "role": "user",
                    "content": f"""Extraia da frase abaixo:
                        - valor (float, usar . como separador decimal)
                        - tipo: "Receita" ou "Despesa"
                        - categoria (uma palavra)
                        - data (DD/MM/YYYY; se não informado,
                            usar {date.today().strftime("%d/%m/%Y")})

                    Frase: "{mensagem}"

                    Retorne APENAS JSON, exemplo:
                        {{"valor": 58,.0, "tipo": "Despesa",
                            "categoria": "Alimentacao",
                            "data": "28/11/2025"}}"""
                }
            ],
            max_tokens=200,
            temperature=0.3
        )
        texto = resposta.choices[0].message.content.strip()
    except Exception as e:
        logger.exception("Erro chamando OpenAI")
        await update.message.reply_text(f"Erro na API de IA: {e}")
        return

    # Extrair JSON do texto
    try:
        start = texto.find("{")
        end = texto.rfind("}") + 1
        if start == -1 or end == 0:
            raise ValueError("Nenhum JSON encontrado na resposta")

        json_text = texto[start:end]
        dados = json.loads(json_text)

        valor = float(dados["valor"])
        tipo = dados["tipo"].capitalize()
        categoria = dados["categoria"].capitalize()
        data_str = dados.get("data", date.today().isoformat()).strip()

        # Validar e normalizar data
        try:
            data_obj = pd.to_datetime(
                    data_str, format="%d/%m/%Y", errors='coerce')
            if pd.isna(data_obj):
                data = date.today().strftime("%d/%m/%Y")
            else:
                data = data_obj.strftime("%d/%m/%Y")
        except Exception as e:
            logger.exception("Erro ao parsear data: %s", e)
            data = date.today().strftime("%d/%m/%Y")

    except Exception as e:
        logger.exception("Erro ao parsear resposta da IA")
        await update.message.reply_text(
            f"Não consegui interpretar. Erro: {e}\nResposta: {texto[:500]}"
        )
        return

    try:
        sheet = abrir_planilha()
        # Adiciona uma nova linha na planilha com os dados extraídos
        sheet.append_row(
            [
                data,
                "",
                categoria,
                valor,
                tipo,
            ]
        )
        await update.message.reply_text(
            f"📌 Registrado!\n\n"
            f"Tipo: {tipo}\n"
            f"Categoria: {categoria}\n"
            f"Valor: R$ {valor:,.2f}\n"
            f"Data: {data}"
        )
    except Exception as e:
        logger.exception("Erro ao salvar na planilha")
        await update.message.reply_text(f"Erro ao salvar na planilha: {e}")

E vamos então analisar a função interpretar(), responsável por extrair os dados de uma mensagem enviada em linguagem natural.

Inicialmente, lemos a mensagem enviada ao Bot. Em seguida montamos um prompt para enviar essa mensagem à IA. Note o contexto no prompt e que pedimos quais dados devem ser extraídos. Ainda é solicitado que esses dados sejam retornados em formato json. É importante observar que, mesmo que tenhamos pedido que a IA retorne apenas json, não há garantia que a resposta será assim. Por isso precisamos tratar adequadamente a resposta.

Observe que podemos enviar uma mensagem com uma data passada, para o caso de termos esquecido de fazer um registro. Mas se não enviarmos a data na mensagem, pedimos à IA que considere o lançamento na data corrente.

A fim de extrair o json da resposta, primeiro buscamos as chaves {}, que envolvem um json. Isso irá garantir que existe um json no texto da resposta e que iremos tratar apenas ele. Daí lemos as chaves fundamentais do nosso registro, que são a data, o valor, a categoria e o tipo.

Lidos esses dados, fazemos o lançamento na planilha. Faça vários testes com a IA, enviando mensagens com dados em ordem diferente, data em vários formatos, a fim de confirmar se o modelo irá tratá-las adequadamente.

Finalmente, para adicionar a função ao bot, inclua a seguinte linha à sequencia de app.add_handler() que já existem no método main().

    app.add_handler(
        MessageHandler(authorized_only & filters.TEXT & ~filters.COMMAND, interpretar))

Implementando autorização de uso

Até então não abordamos o tema autorização, que trata de como o bot lida com o acesso de pessoas que não tem permissão para usar os recursos disponíveis. Isso é importante, visto que se trata de um bot de uso pessoal. Ele manipula uma planilha Google Sheets de uso pessoal, e, sendo o bot de acesso público, é fundamental tratar essa questão.

No código do nosso bot nós utilizamos o módulo filters, o qual permite que o bot decida qual mensagem ou comando ele deve tratar. Existem filtros nativos da biblioteca e filtros personalizados, que podem ser criados pelo desenvolvedor.

Neste caso, optamos por um filtro personalizado. Mas a biblioteca oferece filters.User(), que permite ao bot tratar mensagens ou comandos de usuários especificados, tanto pelo ID quanto pelo username.

No filtro que fizemos, foi criada uma lista de IDs de usuários autorizados, a qual mantemos no arquivo .env. Então, sempre que o usuário envia uma mensagem ao bot, o filtro executa e verifica de o ID do uauário pertence a essa lista. Veja como está implementado o filtro:

CHAT_ID_LIST = ast.literal_eval(os.getenv("CHAT_ID_LIST", "[]"))
OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")


client = OpenAI(api_key=OPENAI_API_KEY)


# Filtro customizado para validação de chat_id
class AuthorizedOnlyFilter(filters.MessageFilter):
    def filter(
            self, update: Update) -> bool:
        if not update or not update.from_user:
            return False
        chat_id = update.from_user.id
        return chat_id in CHAT_ID_LIST


# Instanciar uma única vez
authorized_only = AuthorizedOnlyFilter()

O filtro é criado como uma subclasse de filters.MessageFilter na sobrescrevemos o método filter(). Nesse método, se o ID do usuário não pertencer à lista, ele retorna False, e a mensagem não é tratada pelo bot.

Criada a classe, nós a instanciamos. E é essa instância que é passada como parâmetro na criação dos handlers de comandos e mensagens no método main():

    app.add_handler(
        CommandHandler(
            "start", start, filters=authorized_only))
    app.add_handler(
        CommandHandler("help", help_command, filters=authorized_only))
    app.add_handler(
        CommandHandler("save", save_command, filters=authorized_only))
    app.add_handler(
        CommandHandler(
            "last", print_last_transactions, filters=authorized_only))
    app.add_handler(
        CommandHandler(
            "diagnostic", diagnostic_command, filters=authorized_only))
    app.add_handler(
        MessageHandler(
            authorized_only & filters.TEXT & ~filters.COMMAND, interpretar))

Confira o código completo no GitHub.

Conclusão

Agora o nosso assistente financeiro aceita registro de despesas por meio do comando /save, usando dados estruturados, ou por meio de uma mensagem em linguagem natural, onde a IA interpreta a mensagem, infere os dados e efetiva o lançamento na planilha Google Sheets.

Essa funcionalidade pode ser melhorada, se definirmos um conjunto de categorias nas quais as depesas podem ser lançadas. Essa função vamos deixar para você implementar.

5 erros que sabotam suas finanças mesmo que você ganhe bem

2025-11-24T22:00:00.014-03:00

5 erros que sabotam suas finanças mesmo que você ganhe bem

Existem pessoas que ganham pouco e conseguem prosperar — e pessoas que ganham muito e vivem no aperto. A diferença raramente está em quanto a pessoa ganha mensalmente. Na verdade, pode estar mais nos hábitos, nos sistemas e na forma como lidamos com o dinheiro no dia a dia.

Fonte: https://br.freepik.com/

Se você já se perguntou por que parece que o dinheiro “escorre entre os dedos”, mesmo tendo um bom trabalho e tendo uma renda acima da média, este post é para você.

A seguir, você vai ver os 5 erros silenciosos que sabotam suas finanças sem que você perceba — e como corrigi-los usando automação, organização e um pouco de tecnologia.

1. Falta de clareza sobre para onde o dinheiro vai

Esse é o erro número 1 pela mesma razão que navegadores marítimos antigos temiam navegar sem mapa: se você não sabe onde está, não sabe para onde vai.

A maioria das pessoas não tem problema de renda. O problema reside em não fazer adequadamente um orçamento, ou não fazer orçamento algum. Gastar o dinheiro sem rastrear sua renda e despesas pode levar a gastos excessivos e acumulação de dívidas.

E muitas vezes o cérebro cria uma armadilha. Você pensa; “Ah, eu sei mais ou menos o quanto eu gasto…”. Só que o “mais ou menos” sempre mascara vazamentos significativos, como aquelas assinaturas esquecidas, gastos pequenos e frequentes com delivery ou o aumento gradual do padrão de vida.

Como corrigir

Crie um sistema automático de registro de gastos. Isso pode evitar erros e a preguiça de fazer esses registros de modo manual. Se quiser algo simples, sugerimos:
- Google Sheets + Scripts em Python: Crie uma planilha com categorias pré-definidas (Moradia, Alimentação, Transporte, Lazer, Investimentos, etc.). Use um script em Python para conectar seu e-mail (onde chegam os comprovantes) ou mesmo seu banco (via API, se disponível) para preencher automaticamente a planilha. Um script simples pode classificar gastos automaticamente com base em palavras-chave. Um ponto de partida pode ser visto no post Como Automatizar suas Finanças Pessoais com Google Sheets e Python
- Um bot no Telegram (como aquele que estamos criando), no qual você registar seus gastos com a simplicidade de enviar um mensagem a um contato, tais como "30 comida" ou "150 transporte". O bot registra o gasto em uma planilha ou banco de dados em tempo real. É rápido, discreto e elimina a pilha de comprovantes.
Use categorias fixas, que são frequentes do seu cotidiano: moradia, alimentação, transporte, lazer, investimentos, etc.
Evite rastrear suas despesas 100% manualmente. Quanto mais automático, mais sustentável.

O ponto está em transformar o rastreamento de uma tarefa chata e manual em um processo passivo e contínuo. A visibilidade total é o primeiro passo para o controle.

2. Não pagar a si mesmo primeiro

Quanto sobra da sua renda no fim do mês? Se a resposta é “quase nada”, você não está sozinho. O problema é que a lógica está invertida.

A maioria faz assim: Recebe → Paga contas → Compra coisas → Se sobrar… investe. O ponto aqui é que nunca sobra.

A regra é simples e inegociável: Investimentos não são o que sobra. São o que vem primeiro, são a prioridade.

Como corrigir

Configure um PIX automático ou transferência agendada. No dia mesmo (ou no dia seguinte) em que seu salário cair na conta, configure uma transferência automática para a sua corretora ou conta de investimentos. Isso não é uma sugestão, é uma lei pessoal. O valor some da sua conta corrente antes que você sequer pense em gastá-lo.
Algumas corretoras oferecem ferramentas com a função "Round-up", que usa IA para arredondar seus gastos no cartão de crédito e investir o troco. Por exemplo, uma compra de R$ 19,70 vira R$ 20,00, e os R$ 0,30 são investidos automaticamente. É uma automação microscópica e poderosa.
Crie uma planilha que projeta o crescimento do seu patrimônio com base no valor mensal que você está investindo. Usar a função FV (Future Value) no Google Sheets para ver o impacto de R$ 500/mês em 20 anos, por exemplo, é um poderoso reforço motivacional. A automação do registro (conectada à sua corretera via API) torna isso vivo.

Automação elimina o “querer” e substitui por “acontecer”, vai garantir que o investimento nunca atrase.

3. Misturar gastos essenciais com estilo de vida

Mesmo quem ganha bem cai nessa armadilha. O exemplo clássico é o "Efeito Inflação do Estilo de Vida": seu salário aumenta, e imediatamente seu padrão de consumo acompanha. O aluguel aumenta, o plano de celular melhora, os restaurantes ficam mais caros. Você ganha mais, mas a sobra é a mesma (ou menor).

Como corrigir

Estratégia das Contas Bancárias Múltiplas. Esta é a forma mais prática de separação física:
- Conta 1 (Salário & Contas Fixas): Para onde seu salário cai. Todas as contas fixas (aluguel, luz, internet, escola) têm débito automático aqui.
- Conta 2 (Estilo de Vida): Para gastos variáveis (lazer, restaurantes, compras). No dia do salário, uma transferência automática de um valor predeterminado (ex: R$ 1.500) é feita da Conta 1 para a Conta 2. Quando o dinheiro acaba, acabou.
Cartões de Crédito Diferentes. Tenha um cartão apenas para gastos essenciais e outro para lazer. A fatura de cada um debita de sua respectiva conta. Isso evita a sensação de que "está sobrando" na conta principal e permite um controle granular.
Alertas em planilhas ou Apps de Controle: Configure alertas nos seus aplicativos de finanças para avisá-lo quando seus gastos com uma categoria (ex: "Restaurantes") ultrapassarem, por exemplo, 80% do limite mensal estabelecido. Neste artigo mostramos como enviar alertas pelo Telegram ou e-mail.

Crie um "orçamento de estilo de vida" com um teto rígido e automático. Seu padrão de vida fica contido, permitindo que o aumento da renda vá para os investimentos, não para o consumo.

4. Não ter um sistema de tomada de decisão financeira

A maioria das pessoas decide financeiramente com base no humor do dia, promoções, impulsos ou na comparação com outras pessoas. O problema não está em gastar — o problema é gastar sem critério.

Como corrigir

Crie um "Checklist de Decisão": Antes de qualquer compra não seja essencial, acima de um determinado valor, por exemplo R$ 200, responda a este questionário:

Necessidade vs. Desejo: Isso é necessário agora ou pode esperar 30 dias? (A Regra dos 30 dias elimina 90% dos impulsos).

Oportunidade: Há algo mais importante que esse dinheiro poderia resolver? (Ex: quitar uma dívida, completar a reserva de emergência).

Alinhamento: Esse gasto me aproxima ou me afasta dos meus objetivos financeiros de curto, médio e longo prazo?

Automatize o Registro da Decisão: Use seu bot do Telegram ou uma planilha com um formulário para registrar toda compra ponderada. Colunas: "Item", "Valor", "Data da Decisão", "Motivo", "Arrependimento (Sim/Não)". Revisar esse histórico mensalmente é um aprendizado brutal sobre seus padrões de consumo.

Use Extensões de Comparação de Preços: Ferramentas como Zoom ou Buscapé oferecem extensões de navegador que, com um clique, usam IA para verificar o histórico de preços de um produto e alertar se é realmente uma promoção ou uma armadilha.

A proposta consiste em substituir a decisão emocional por um processo racional e documentado. A sistemática vence a impulsividade.

5. Depender da força de vontade (e não de sistemas)

Esse é o erro mais cruel. As pessoas tentam controlar o dinheiro com força de vontade, disciplina e promessas de “agora vai”. Mas a neurociência é clara: a força de vontade é um recurso finito e cansável. Um sistema automático é robusto e não cansa.

Como corrigir

Implemente sistemas automáticos:

Sistema de Débitos Automáticos Totais. Automatize TUDO que for essencial e previsível: aluguel, condomínio, contas de consumo, internet, seguros, e o mais importante, os investimentos.
Painel de Controle em Tempo Real (Dashboard). Crie um painel numa planilha avançada que se atualize automaticamente (via importação de dados ou APIs). Esse painel deve mostrar: saldo das contas, gastos por categoria, progresso das metas de investimento, etc. A visão macro e automática tira o peso da microgestão.
Alertas proativos com Apps Script/Python. Programe scripts simples que analisam sua planilha e disparam e-mails ou mensagens no Telegram quando detectam anomalias. Ex: "Seu gasto com 'Lazer' neste mês já é 50% maior que a média dos últimos 3 meses" ou "Sua conta corrente está abaixo do limite de segurança". A IA, neste caso, pode atuar como seu assistente financeiro pessoal.

A ideia é automatizar sua gestão financeira. Você não precisa ser disciplinado todos os dias; você só precisa ter disciplina uma vez para montar o sistema. Depois, o sistema trabalha para você. Claro, precisa seguir aprimorando sempre.

Conclusão

Ganhar bem ajuda — claro que ajuda. Mas não resolve.

O que resolve é ter sistemas, clareza e hábitos financeiros inteligentes. A boa notícia é que a tecnologia está do seu lado. Ferramentas que antes eram restritas a grandes empresas — como automação, análise de dados e IA — agora estão ao alcance de qualquer pessoa com um smartphone e um pouco de curiosidade.

Você não precisa se tornar um escravo do controle. Pelo contrário: ao automatizar o que é chato, repetitivo e sujeito a falhas humanas (como a força de vontade), você libera sua mente e seu tempo para o que realmente importa: viver a vida que o seu dinheiro, bem gerido, pode proporcionar.

Comece hoje. Escolha um dos 5 erros e implemente a correção. O seu futuro eu agradece.

Seu Assistente Financeiro Pessoal no Telegram: Integrando IA ao Bot do Google Sheets

2025-11-22T08:22:00.006-03:00

Seu Assistente Financeiro Pessoal no Telegram: Integrando IA ao Bot do Google Sheets

Tempo de leitura: 10 minutos

Criar um assistente financeiro pessoal pode ser um grande desafio. Mas com a combinação de Python, Telegram Bot API, Google Sheets e OpenAI, você pode construir uma ferramenta capaz de analisar despesas e receitas, organizar planilhas, gerar diagnósticos financeiros automáticos usando IA e até ajudar outras pessoas a cuidar do dinheiro.

Neste artigo, você vai aprender passo a passo como integrar uma Inteligência Artificial ao bot de Telegram criado no post anterior, a qual será capaz de atuar como um verdadeiro assistente financeiro.

Fonte: https://br.freepik.com/

Pré-requisitos

Recomendamos que você já tenha criado o Bot Telegram descrito neste post
Bibliotecas pandas e openai
Conta na OpenAI

Em posts anteriores aprendemos como criar um Bot Telegram, que faz registros de transações numa planilha Google Sheets. Vamos utilizar este bot e implementar um upgrade, que adiciona a funcionalidade da ferramenta fazer um diagnóstico das nossas finanças e oferecer insights com base nesse diagnóstico. Essa nova funcionalidade do bot será implementada utilizando uma IA, mais especificamente um modelo da OpenAI.

Considerando que vamos partir do código funcionando, criado no artigo anterior, será necessário instalar as bibliotecas:

pip install openai pandas

Desde que você já possua uma conta, a fim de obter um token da API OpenAI, precisamos criá-lo no dashboard da plataforma.

Dashboard da OpenAI Platform

Clique no botão Create new secret key no canto superior direito. Opcionalmente, você pode dar um nome à sua chave para identificação (ex: "Meu Projeto BOT") e, em seguida, clique em Create key. O seu token (chave secreta) será exibido em uma janela. Copie-o imediatamente e guarde-o em um local seguro, pois, por motivos de segurança, você não conseguirá vê-lo novamente depois de fechar a janela.

A utilização da API da OpenAI geralmente envolve custos baseados no uso (pago por token/uso), e pode ser necessário adicionar um método de pagamento à sua conta para utilizar os serviços. Por exemplo, cerca de 1.000 tokens pode ter um custo $ 0.50, dependendo do modelo utilizado. Para saber mais sobre como os tokens são contados e precificados leia aqui.

Um pouco mais sobre segurança

Num post anterior introduzimos a utilização de dotenv para guardar as chaves secretas. Esse será o mecanismo utilizado também para guardar nossa chave da API da OpenAI. Neste upgrade do nosso bot vamos passar a guardar as credenciais da conta de serviço do Google Cloud que aprendemos a criar neste artigo, também no arquivo .env.

A dica consiste em criar uma chave no .env, por exemplo:

CREDENCIAIS_GOOGLE_SHEETS={"type": "service_account", "project_id": "xxxxxxxxxxxxxxxxxxxxxx", "private_key_id": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx","private_key": "-----BEGIN PRIVATE KEY-----"}

O nome da chave pode ser qualquer um, e o valor é o conteúdo do arquivo json que você baixou quando criou a chave. Sendo que o conteúdo deve estar em forma de string json. Para isso ponha o conteúdo em uma única linha.

Agora precisamos modificar o arquivo utils.py que foi criado no post anterior.

utils.py

CREDENCIAIS = os.getenv("CREDENCIAIS_GOOGLE_SHEETS")


def conectar_google_sheets():
    scopes = [
        "https://www.googleapis.com/auth/spreadsheets",
        "https://www.googleapis.com/auth/drive",
    ]

    # creds = Credentials.from_service_account_file(
    #     "credenciais.json", scopes=scopes)
    json_credencials = json.loads(CREDENCIAIS)
    creds = Credentials.from_service_account_info(
        json_credencials, scopes=scopes)

    client = gspread.authorize(creds)
    return client

Note que incluimos uma linha que obtém CREDENCIAIS do arquivo .env e, na função conectar_google_sheets(), substituimos a linha que define creds. Antes ela precisava ler o arquivo credenciais.json e agora utilizamos json.loads() para converter a string CREDENCIAIS em json e definimos creds para buscar as informações desse json.

O que vamos criar

Iremos incluir o comando /diagnostic ao código do Bot Telegram criado no artigo anterior, o qual será responsável por receber a planilha de transações, gerar um resumo e com base nesse resumo, a IA irá fazer, por meio de um relatório, um diagnóstico e propor algumas recomendações para economizar, reduzir despesas, etc.

O resumo financeiro

O resumo será gerado por meio da função gerar_resumo_financeiro(), que recebe como parâmetro a planilha de transações convertida em um Dataframe, o que possibilita um tratamento de dados mais facilitado.

# Outros imports aqui
import panda as pd

# Algum código aqui

def gerar_resumo_financeiro(df: pd.DataFrame) -> dict:
    """
    Espera colunas: ['Data','Descrição','Categoria','Tipo','Valor', ...]
    Tipo é 'Receita' ou 'Despesa' (case-insensitive)
    """
    df = df.copy()
    # garantir colunas mínimas
    required = ['Data', 'Descrição', 'Categoria', 'Tipo', 'Valor']
    # tentar mapear colunas sem acento
    # assume que o usuário usou cabeçalhos corretos
    for col in required:
        if col not in df.columns:
            raise ValueError(
                f"A coluna obrigatória '{col}' não foi encontrada na planilha."
                )

    # converter tipos
    df['Valor'] = pd.to_numeric(df['Valor'], errors='coerce').fillna(0.0)
    df['Tipo'] = df['Tipo'].astype(str).str.strip().str.capitalize()
    # garantir datas
    try:
        df['Data'] = pd.to_datetime(df['Data'], dayfirst=True, errors='coerce')
    except Exception:
        df['Data'] = pd.to_datetime(df['Data'], errors='coerce')

    # calcular métricas básicas
    receitas = df.loc[df['Tipo'] == 'Receita', 'Valor'].sum()
    despesas = df.loc[df['Tipo'] == 'Despesa', 'Valor'].sum()
    saldo = receitas - despesas
    taxa_poupanca_pct = (saldo / receitas * 100) if receitas != 0 else 0.0

    # distribuição por categoria (somente despesas)
    despesas_por_cat = (
        df.loc[df['Tipo'] == 'Despesa']
        .groupby('Categoria')['Valor']
        .sum()
        .sort_values(ascending=False)
        .to_dict()
    )

    # dívida detectada: categoria chamada 'Dívidas' ou 'Dividas'
    dividas = 0.0
    for key in ['Dívidas', 'Dividas', 'Divida', 'Dívida']:
        if key in df['Categoria'].unique():
            dividas += df.loc[
                (df['Categoria'] == key) & (df['Tipo'] == 'Despesa'), 'Valor'
                ].sum()

    resumo = {
        "receitas": round(float(receitas), 2),
        "despesas": round(float(despesas), 2),
        "saldo": round(float(saldo), 2),
        "taxa_poupanca_pct": round(float(taxa_poupanca_pct), 2),
        "despesas_por_categoria":
            {str(k): float(v) for k, v in despesas_por_cat.items()},
        "dividas": round(float(dividas), 2),
        "periodo_inicio": str(df['Data'].min()) if
            not df['Data'].isnull().all() else None,
        "periodo_fim": str(df['Data'].max()) if
            not df['Data'].isnull().all() else None,
    }
    return resumo

Antes de criar o resumo, a função checa se a planilha tem as colunas obrigatórias. Não importa a ordem, se estão em maiúsculas ou não ou se possuem acentuação.

Em seguida é feita a conversão de tipos, tanto os numéricos quanto as strings, e a formatação adequada das datas. Tudo isso para assegurar a criação do resumo, visto que, por exemplo, será necessário totalizar cada categoria, e isso exige que cada uma delas tenha denominação padronizada na planilha inteira.

Finalmente, a função cria e retorna o resumo na forma de um dict.

O prompt

O prompt que será enviado ao modelo é montado na função montar_prompt_para_openai(). A função recebe o resumo criado na função anterior e o envia no prompt. Note que o prompt é bastante específico, detalhando o que se quer da IA. No entanto não é um texto fechado, você sempre pode e deve melhorá-lo.

def montar_prompt_para_openai(resumo: dict) -> str:
    # Template em PT-BR para o modelo receber e gerar diagnóstico
    prompt = f"""
    Você é um especialista em finanças pessoais. Analise o resumo financeiro
    abaixo e gere um relatório de diagnóstico completo, claro e motivador.
    Divida o relatório em: Visão geral, Principais pontos de atenção,
    Oportunidades de economia, Plano de ação (3 a 5 passos) e Recomendação
    de produtos/contas para reserva de emergência.
    Seja prático e dê números concretos (valores em reais e percentuais).

    Resumo financeiro (auto-gerado):
    - Período: {resumo.get('periodo_inicio')} até {resumo.get('periodo_fim')}
    - Receitas totais: R$ {resumo.get('receitas'):.2f}
    - Despesas totais: R$ {resumo.get('despesas'):.2f}
    - Saldo: R$ {resumo.get('saldo'):.2f}
    - Taxa de poupança (% sobre a receita):
        {resumo.get('taxa_poupanca_pct'):.2f}%
    - Dívidas identificadas (valor): R$ {resumo.get('dividas'):.2f}
    - Distribuição das maiores categorias de despesa:
        {resumo.get('despesas_por_categoria')}

    Dê recomendações específicas com valores (ex.: "reduza X na categoria Y,
    isso economiza R$ Z por mês") e proponha metas (ex.: reserva de emergência
    equivalente a N meses de despesas).
    """
    return prompt

A função retorna então esse prompt detalhado, o qual contém informações do resumo.

O comando /diagnostic

O primeiro passo na função diagnostic_command() é conectar ao Google Sheets e ler a planilha alvo no formato de um list de dict. Em seguida, por meio de pd.DataFrame(), converter esse list em um DataFrame.

async def diagnostic_command(
        update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    cliente = conectar_google_sheets()
    planilha = cliente.open("Minhas Finanças Pessoais")
    sheet = planilha.worksheet("Transações")
    registros = sheet.get_all_records()
    df = pd.DataFrame(registros)
    try:
        resumo = gerar_resumo_financeiro(df)
    except Exception as e:
        logger.exception("Erro no resumo financeiro")
        await update.message.reply_text(f"Erro ao processar os dados: {e}")
        return
    prompt = montar_prompt_para_openai(resumo)
    # chamada básica para OpenAI (Chat Completions)
    try:
        response = client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=[
                {"role": "developer",
                 "content":
                     """Você é um assistente especialista
                     em finanças pessoais."""},
                {"role": "user", "content": prompt}
            ],
            max_tokens=800,
            temperature=0.3)
        texto_relatorio = response.choices[0].message.content.strip()
    except Exception as e:
        logger.exception(f"Erro chamando OpenAI {e}")
        await update.message.reply_text(
            f"Erro ao gerar o relatório via OpenAI {e}")
        texto_relatorio = (
            "Relatório automático (fallback):\n\n"
            f"Receitas: R$ {resumo['receitas']}\n"
            f"Despesas: R$ {resumo['despesas']}\n"
            f"Saldo: R$ {resumo['saldo']}\n"
            f"Taxa poupança: {resumo['taxa_poupanca_pct']}%\n"
        )

    # enviar resultados
    # primeiro um resumo curto
    resumo_msg = (
        f"✅ Diagnóstico pronto!\n\n"
        f"Receitas: R$ {resumo['receitas']:.2f}\n"
        f"Despesas: R$ {resumo['despesas']:.2f}\n"
        f"Saldo: R$ {resumo['saldo']:.2f}\n"
        f"Taxa de poupança: {resumo['taxa_poupanca_pct']:.2f}%\n\n"
        "Relatório completo em anexo (PDF) e abaixo em texto."
        )
    await update.message.reply_text(resumo_msg)
    await update.message.reply_text(texto_relatorio)

A seguir é chamada a função gerar_resumo_financeiro() passando o DataFrame como argumento. Esta função retorna o resumo, o qual é passado para a função montar_prompt_para_openai(). Esta função retorna o prompt montado.

Com o prompt disponível, é chamada a função client.chat.completions.create(). Esta função é uma chamada à API da OpenAI, que pode interagir com vários modelos da família GPT, bastando especificá-lo no parâmetro model. Além do parâmetro model, é obrigatório o envio de messages, que é uma lista das mensagens da conversa. Messages deverá ter um item de developer e outro de user, no qual passamos o prompt que foi montado antes. O parâmetro max_tokens é usado para controlar os custos das respostas. Por sua vez, temperature determina a aleatoriedade da resposta. Quanto menor o valor, mais focada é a resposta. Seu valor deve estar em 0 e 2.

Para finalizar, o handler do comando /diagnostic é registrado no bot.

Código completo disponível no GitHub.

Conclusão

Agora temos um bot pessoal no Telegram, que facilita o trabalho de lançar as transações na planilha e se integra a uma Inteligência Artificial para, com base nessa planilha, fazer uma análise desses dados e fornecer recomendações a fim de aprimorarmos a getão das nossas finanças.

Esse código é apenas um ponto de partida. Uma das melhorias que podemos implementar é pedir à nossa IA fazer o lançamento na planilha a partir de uma mensagem não estruturada. Por exemplo, podemos enviar a mensagem paguei 150,00 num almoço. E a partir disso modelo infere categorias, descrições, valores, etc.

Como criar um Bot Telegram para atualizar uma planilha financeira no Google Sheets

2025-11-17T08:41:00.008-03:00

Como criar um Bot Telegram para atualizar uma planilha financeira no Google Sheets

Tempo de leitura: 10 minutos

Nesse post nós mostramos como automatizar uma planilha financeira pessoal usando Python. Vimos como atualizar as transações a partir de um arquivo de extrato bancário em csv. Todavia, muitas transações no nosso dia a dia não são feitas por meio de um banco. Podem ser feitas em dinheiro, ou usando cartão de crédito. E seja numa planilha como foi apresentado, ou utilizando um app de finanças pessoais, fazer esses lançamentos no momento que ocorrem pode demandar algum tempo, e se deixarmos para fazer posteriormente, isso é passível de esquecimento. E se pudéssemos fazer isso por meio do envio de uma mensagem instantânea? Neste artigo iremos mostrar como criar um bot Telegram usando Python, que recebe essa mensagem e faz o registro da transação na nossa planilha.

Fonte: https://br.freepik.com/

Pré-requisitos

Conta no Google e credenciais no Google Cloud
Python e bibliotecas instaladas
Bot Telegram

Já vimos num post anterior como criar credenciais no Google Cloud e também o código Python que faz essa conexão com nossa planilha. Já, neste outro artigo, mostramos como criar um Bot Telegram. Aqui, vamos utilizar o mesmo bot.

Instale as bibliotecas que serão necessárias:

pip install python-dotenv python-telegram-bot gspread google-auth

Iniciando a implementação

Um script para bot Telegram deve ficar executando e a determinado intervalo de tempo, checa se o usuário interagiu enviando algum comando. Se o comando enviado for válido, ou seja, estiver entre os comandos previstos no script, o bot irá responder enviando uma simples mensagem ou executando uma ação mais complexa. Neste script inicial, nosso bot, responde com uma mensagem de boas vindas ao comando /start.

finance_bot.py

from dotenv import load_dotenv
import os
from telegram import Update
from telegram.ext import (
    ApplicationBuilder,
    CommandHandler,
    ContextTypes)
load_dotenv()

TELEGRAM_TOKEN = os.getenv("TELEGRAM_TOKEN")


# Handlers
async def start(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    await update.message.reply_text(
        ("Seja bemvindo ao Finance Bot! "
         "Envie /help para ver os comandos disponíveis.")
    )

# Os demais handlers serão inseridos aqui

def main():
    if not TELEGRAM_TOKEN:
        raise RuntimeError("Defina as variáveis de ambiente TELEGRAM_TOKEN.")

    app = ApplicationBuilder().token(TELEGRAM_TOKEN).build()

    app.add_handler(
        CommandHandler("start", start))
    app.run_polling()


if __name__ == "__main__":
    main()

A fim de implementar o script do bot iremos precisar do token que você anotou quando criou o seu bot seguindo os passos que foram descritos em post anterior. Recomendamos que este token e outros dados sensíveis sejam mantidos em um arquivo .env e sejam utilizados em nosso programa por meio da biblioteca dotenv, assim como explicamos nesse post.

Após essas definições iniciais, tais como os imports e a inicialização do token, partimos para a criação dos handlers, que é como chamamos as funções que devem ser executadas em resposta aos comandos.

O primeiro handler que implementamos é o start, que será executado quando enviarmos o comando /start. Não é necessário que o nome do handler seja exatamente o mesmo nome do comando. Mais adiante explicamos o porquê.

Na assinatura da função observe que temos uma palavra-chave async. Essa palavra-chave define que uma função é assíncrona, ou seja, que executa de modo concorrente, sem bloquear a thread principal. Geralmente as chamadas à API, acessos a banco de dados, entre outros, precisam desse cuidado, pois são tarefas que demandam tempo para responder.

Ainda no contexto da função start(), a chamada reply_text(), que envia uma mensagem ao usuário, é precedida de um await, que serve para pausar a execução da função até que esta chamada seja resolvida. Um await só pode ser utilizado no contexto de uma função async.

Depois dos handlers, temos a função main(), que efetivamente irá executar o bot. Ela que cria uma instância do bot, adiciona os handlers e executa o script.

Antes de qualquer coisa nós verificamos se há um token definido, depois criamos a instância do bot. Na linha seguinte adicionamos o handler que foi definido. Note que a classe CommandHandler tem dois parâmetros: uma string, que será o comando ao qual o bot irá responder, e um segundo parâmetro que é o nome da função handler. Daí o porquê de comando e função não precisarem ter o mesmo nome.

Finalmente, chamamos o método run_polling(), que inicia o bot e o mantém executando continuamente buscando atualizações do servidor Telegram. Esse método bloqueia a thread corrente até que o processo seja interrompido, teclando CTRL + C.

Execute o script digitando no terminal python finance_bot.py. Se tudo estiver certo procure o bot pelo nome no Telegram e envie /start e você deve receber a mensagem de boas vindas.

Maneiras de executar o Bot Telegram

Antes de prosseguirmos com o nosso código, precisamos falar das maneiras de manter um bot Telegram executando.

Chamar run_polling() no terminal é uma maneira de testar nosso código. Assim, é possível checar se o bot está ouvindo as mensagens e respondendo. O uso de polling é possível fazer em servidores como Render, Railway, entre outros, de uma maneira bem simples, mas tem o inconveniente de o bot sair do ar se o processo parar ou precisar reiniciar.

Uma maneira mais profissional consiste em utilizar um webhook. Esse sistema é utilizado para que dois sistemas se comuniquem, e um deles é comunicado quando um evento acontece, em vez de precisar ficar verificando periodicamente se esse evento aconteceu, tal como no polling.

Tem a vantagem de estar sempre disponível, mas precisa de um endpoint (criado com Flask ou FastAPI, por exemplo) e de um domínio HTTPS e certificado SSL. No próprio Render é possível hospedar um webhook. Já o Ngrok é um serviço que possibilita que o webhook fique rodando em nosso computador. De todo modo, assinar esses serviços no plano gratuito tem o inconveniente do serviço "dormir" devido a algum tempo de inatividade e o Telegram pode não esperar (devido o timeout) e nossa mensagem ao bot vai ficar sem resposta.

Este tema é um pouco avançado e não cabe no escopo deste artigo. Mas se houver interesse podemos apresentá-lo em um post no futuro.

Escrevendo os demais handlers

Os outros handlers do nosso bot deverão responder aos comandos /help, que exibe uma ajuda sobre os comandos disponíveis, /save, responsável por registrar um lançamento na planilha, e /last que vai exibir os últimos 5 lançamentos que foram feitos.

O código de tais handlers serão incluídos logo após o start(). Iniciamos mostrando o help_command(), o qual é semelhante ao start(), e não necessita maiores comentários.

async def help_command(
        update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    help_text = (
        "Comandos disponíveis:\n"
        "/start - Iniciar o bot\n"
        "/help - Mostrar esta mensagem de ajuda\n"
        "/save - Salvar um lançamento na planilha\n"
        "   /save valor/categoria/tipo/descrição (descrição é opcional)\n"
        "   Tipo deve ser 'Despesa' ou 'Receita'\n"
        "   Exemplo: /save 50,00/Alimentação/Despesa/Jantar com amigos\n"
        "/last - Mostrar as últimas 5 transações\n"
    )
    await update.message.reply_text(help_text)

Antes de comentarmos o próximo handler, save_command(), precisamos falar do módulo utils.py, que tem duas funções auxiliares. Primeiro, conectar_google_sheets(), responsável por fazer a conexão com a API do Google Sheets, a qual já utilizamos nos posts anteriores, e normalizar_string(), que converte strings para um formato específico, o qual possibilita totalizações e comparações na planilha.

utils.py

import gspread
import unicodedata
import os
from google.oauth2.service_account import Credentials


def conectar_google_sheets():
    scopes = [
        "https://www.googleapis.com/auth/spreadsheets",
        "https://www.googleapis.com/auth/drive",
    ]

    creds = Credentials.from_service_account_file(
        "credenciais.json", scopes=scopes)

    client = gspread.authorize(creds)
    return client


def normalizar_string(s: str) -> str:
    normalized = unicodedata.normalize('NFKD', s)
    folded = "".join([c for c in normalized if not unicodedata.combining(c)])
    return folded.casefold()

Este módulo necessita que gspread seja instalado e importado para lidar com planilhas Google. Veja este artigo para saber mais sobre se conectar à API Google Sheets.

A função normalizar_string() precisa do pacote unicodedata, nativo do Python. Ela é reponsável por substituir caracteres acentuados e cedilha, e converter uma string em caixa baixa.

# Acrescente estes imports
from datetime import date
from utils import (
    conectar_google_sheets,
    normalizar_string)

# Handler save
async def save_command(
        update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    # Verifica se o usuário forneceu argumentos
    if not context.args:
        await update.message.reply_text(
            ("Por favor, forneça informações a registrar separadas por /."
             "Digite no formato: valor/categoria/tipo/descrição."
             "Descrição é opcional."
             )
        )
        return
    # Obtém os dados fornecidos pelo usuário e separa-os
    dados = context.args[0].split("/")
    # Verifica se há pelo menos 3 partes (valor, categoria, tipo)
    if len(dados) <= 3:
        await update.message.reply_text(
            ("Formato inválido. Use: valor/categoria/tipo/descrição"
             )
        )
        return
    # Valida o valor fornecido
    valor = dados[0].replace(",", ".")
    try:
        float(valor)
    except ValueError:
        await update.message.reply_text(
            "O valor deve ser um número. Por favor, tente novamente."
        )
        return
    cliente = conectar_google_sheets()
    planilha = cliente.open("Minhas Finanças Pessoais")
    sheet = planilha.worksheet("Transações")
    # Adiciona uma nova linha na planilha com os dados fornecidos
    sheet.append_row(
        [
            date.today().strftime("%d/%m/%Y"),
            dados[3] if len(dados) > 3 else "",
            normalizar_string(dados[1]).capitalize(),
            float(valor),
            normalizar_string(dados[2]).capitalize(),
        ]
    )
    # Dá feedback ao usuário
    await update.message.reply_text(
        f"""
        Você registrou: {dados[0]} para {dados[1]}
        no dia {date.today().strftime('%d/%m/%Y')}.
        """
    )

O comando /save é o mais complexo do nosso bot, até o momento. O comando /help diz como deve ser o formato de /save e dá um exemplo: /save 50,00/Alimentação/Despesa/Jantar com amigos. Ou seja, /save tem argumentos, que são os dados a serem registrados na planilha. A fim de assegurar um mínimo de estrutura nos dados, são necessárias algumas validações, as quais são tratadas pelo handler.

Assim, o primeiro passo é verificar se foram digitados os arguntos após o /save. Depois é verificado se existem pelo menos três informações nos argumentos, visto que Descrição é opcional. Em seguida tratamos o valor numérico da transação, que deve ser um float.

Após tudo validado, a função faz a conexão com a API, e faz um apend_row() desses dados na planilha. Feito isso, o bot nos dá um feedback, avisando que o registro foi feito.

Finalmente incluimos o handler print_last_transactions(), o qual irá retornar os cinco últimos registros feitos na planilha.

async def print_last_transactions(
        update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    cliente = conectar_google_sheets()
    planilha = cliente.open("Minhas Finanças Pessoais")
    sheet = planilha.worksheet("Transações")
    registros = sheet.get_all_records()
    ultimos = registros[-5:]  # Últimas 5 transações
    mensagem = "Últimas 5 transações:\n"
    for registro in ultimos:
        mensagem += (
            f"{registro['Data']}: {registro['Tipo']} de "
            f"{registro['Valor']} em {registro['Categoria']} - "
            f"{registro['Descrição']}\n"
        )
    await update.message.reply_text(mensagem)

Esta função se conecta à API, lê todos os registros da planilha em uma lista denominada registros, e pega os últimos 5. Em seguida, é montada uma string com os dados desses últimos registros e então essa string é exibida como retorno de /last.

E agora, precisamos adicionar esses handlers ao bot. Isso é feito na função main(), incluindo estas linhas logo abaixo de app.add_handler():

app.add_handler(
        CommandHandler("help", help_command))
app.add_handler(
        CommandHandler("save", save_command))
app.add_handler(
        CommandHandler(
            "last", print_last_transactions))

O código completo do bot pode ser encontrado no GitHub.

Conclusão

Este bot foi projetado com o propósito de facilitar o registro de transações no cotidiano. Alguns cuidados, no entanto, precisamos ter. O primeiro deles é não expor dados sensíveis como senhas, tokens, entre outros. Procuramos orientar o uso de dotenv para manter esses dados em variáveis de ambiente. Nossas credenciais da API Google Sheets ainda estão em um arquivo, mas em breve mostraremos como passar a tratar esses dados também no dotenv.

Outra preocupação é que, ao você executar o código, seja pelo método polling ou webhook, seja no seu próprio computador ou em um serviço de nuvem, qualquer usuário do Telegram pode acessá-lo. Existem maneiras de evitar isso e, mesmo não tendo nos referido a isso no artigo, o código está presente na versão que compartilhamos no GitHub.

Por fim, vamos continuar trabalhando nesse projeto. E a próxima funcionalidade que será implementada consiste de automação com uma IA de modo que ela faça uma análise dos dados na planilha e produza um diagnóstico financeiro.

Como enviar notificações por e-mail ou pelo Telegram

2025-11-10T17:29:00.011-03:00

Como enviar notificações por e-mail ou pelo Telegram

Tempo de leitura: 7 minutos

Nos dois últimos posts, mostramos algumas tarefas relacionadas a finanças pessoais, que podem ser agendadas para executar periodicamente e/ou que podem ajudar mais ainda se puderem enviar notificações. Por esse motivo iremos apresentar scripts para automatizar a notificação ao usuário tanto por e-mail (Gmail, no nosso exemplo) quanto por mensagem instantânea (Telegram, principalmente pelo fato do recurso que precisamos ser gratuito).

Fonte: https://br.freepik.com/

Mantendo suas chaves em segurança

Antes de iniciar o assunto objeto deste artigo, é importante falar como cuidar da segurança de chaves, tokens e senhas nas nossas aplicações. Introduzimos este assunto aqui, porque iremos lidar com dados que precisam ser mantidos em sigilo.

O primeiro passo é instalar o pacote dotenv, uma biblioteca que permite carregar variáveis de ambiente a partir de um arquivo .env.

pip install python-dotenv

Em seguida vamos criar um arquivo denominado .env na raiz do projeto. Esse arquivo irá conter variáveis de ambiente no formato NOME_DA_VARIAVEL=VALOR. Por exemplo:

EMAIL_USUARIO=usuario123456@gmail.com
EMAIL_SENHA=abcdefghijkl
TOKEN=abcdefghijklmnopqrstuvwxyz
CHAT_ID=1001943736541

Agora criaremos nossos scripts de notificação, quando voltaremos ao dotenv.

Script para enviar noticação utilizando o Gmail

A fim de fazer essa implementação, siga os seguintes passos:

1) Em primeiro lugar, obtenha uma senha de App seguindo as instruções descritas neste link.

Um requisito para criar uma senha de App é que a verificação em duas etapas esteja ativada na sua conta Google.

Cumprida essa exigência, crie uma senha de App. Talvez seja pedido para fazer login na sua conta Google. Após isso, irá aparecer essa tela:

Tela de criação da senha de App

Digite o nome do App e clique em Criar. Será mostrada a senha de 16 dígitos. Copie esse senha agora, ignorando os espaços. Após fechat a tela, você não terá como visualizar ou editá-la, apenas poderá excluí-la.

2) Em seguida, escreva o script de acordo com nossas instruções.

Crie um arquivo .env com este conteúdo, na mesma pasta onde se encontra o programa que enviará o e-mail:

EMAIL_USUARIO=seu email de usuário do Gmail
EMAIL_SENHA=a senha de App criada, sem os espaços

Nosso script inicia com as seguintes importações e inicializações, considerando que já instalou python-dotenv:

# Pacote que permite interagir com SMTP
import smtplib
# Pacote que permite lidar com variáveis de ambiente
from dotenv import load_dotenv
# Pacote para lidar com funções do Sistema Operacional
import os

# Lê variáveis do arquivo .env e as define em os.environ
load_dotenv()

E a função completa, que inicializa um servidor SMTP, informa que queremos enviar e-mail de forma segura usando o protocolo TLS, faz login utilizando o e-mail de usuário e a senha de App e finalmente envia mensagem e encerra a instância de SMTP:

send_email.py

import smtplib
de ambiente
from dotenv import load_dotenv
import os

load_dotenv()


def enviar_email(assunto, mensagem):
    servidor_smtp = smtplib.SMTP('smtp.gmail.com', 587)
    servidor_smtp.starttls()
    email = os.getenv('EMAIL_USUARIO')
    servidor_smtp.login(email, os.getenv('EMAIL_SENHA'))
    servidor_smtp.sendmail(
      email, email, f'Subject: {assunto}\n\n{mensagem}')
    servidor_smtp.quit()

Neste exemplo, estamos enviando o e-mail para nós mesmos, por isso os dois primeiros parâmetros de sendmail() são iguais: o remetente e o destinatário são o mesmo usuário.

Agora podemos juntar o script para monitorar cotação de moeda do post anterior com este para enviar um e-mail de alerta:

import requests
from send_email import enviar_email

LIMITE_SUPERIOR = 5.3
LIMITE_INFERIOR = 5.0


def monitorar_cotacao():
    API_URL = "https://economia.awesomeapi.com.br/last/USD-BRL"
    resp = requests.get(API_URL)
    data = resp.json()
    cotacao_dolar = float(data["USDBRL"]["bid"])
    return cotacao_dolar


if __name__ == "__main__":
    cotacao_atual = monitorar_cotacao()
    if cotacao_atual > LIMITE_SUPERIOR:
        enviar_email(
            "Alerta de Cotacao",
            f"A cotacao do dolar subiu para {cotacao_atual:.2f} BRL.",
        )
    elif cotacao_atual < LIMITE_INFERIOR:
        enviar_email(
            "Alerta de Cotacao",
            f"A cotacao do dolar caiu para {cotacao_atual:.2f} BRL.",
        )

Script para enviar mensagem pelo Telegram

Para este script, precisamos seguir estes passos:

1) Criar um bot no BotFather e obter o token de API

Inicialmente abra o Telegram e procure o usuário @BotFather. Este usuário ajuda a criar e gerenciar bots Telegram. Se você enviar a mensagem /start, ele mostrará todos os comandos que ele pode responder. Assim, para criar um novo bot envie a mensagem /newbot, e siga as instruções. Logo que concluir a criação ele lhe mostrará o token de acesso. Copie-o e o mantenha seguro, pois vamos precisar dele no nosso script.

Em seguida é necessário obter o seu CHAT_ID. Existem algumas alternativas. Uma delas é localizar o usuário @userinfobot e enviar a mensagem /start. Ele irá responder algumas informações, dentre elas Your ID. Copie esse número. É o seu CHAT_ID.

2) Se já tiver instalado python-dotenv, escreva o scrpit conforme as instruções a seguir:

Crie um arquivo .env ou, se existir um na mesma pasta onde estará este novo script, abra-o e inclua as seguintes linhas:

TELEGRAM_TOKEN=seu token de API
CHAT_ID=seu chat_id

Instale a biblioteca:

pip install python-telegram-bot

E escreva o script:

send_msg_telegram.py

# asyncio é uma biblioteca padrão do Python para programação assíncrona.
import asyncio
import telegram
from dotenv import load_dotenv
import os

load_dotenv()

# Configurações do bot do Telegram
TOKEN = os.getenv('TELEGRAM_TOKEN')
CHAT_ID = os.getenv('CHAT_ID')


async def enviar_mensagem(texto):
    bot = telegram.Bot(token=TOKEN)
    await bot.send_message(chat_id=CHAT_ID, text=texto)


# Exemplo de uso
mensagem = "Olá! Esta é uma mensagem enviada do Python."
asyncio.run(enviar_mensagem(mensagem))

Ao executar esse script você deve receber uma mensagem do bot com nome de usuário que você criou.

Agora podemos incrementar a automação que monitora concursos do post anterior, usando este script para enviar uma notificação pelo Telegram:

import requests
from bs4 import BeautifulSoup
from send_msg_telegram import enviar_mensagem
import asyncio


def verificar_concursos(palavras_chave=[]):
    url = "https://www.pciconcursos.com.br/"
    headers = {
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3"
    }
    response = requests.get(url, headers=headers)
    page_contents = BeautifulSoup(response.text, "html.parser")

    noticias = page_contents.find("div", id="noticias_capa")
    # Procure por palavras-chaves na página
    exist = any(elemento in noticias.get_text().lower() for elemento in palavras_chave)

    return exist


if __name__ == "__main__":
    if verificar_concursos(
        [
            "desenvolvedor",
            "programador",
            "engenheiro de software",
            "tecnologia da informação",
        ]
    ):
        asyncio.run(
            enviar_mensagem(
                "Novo concurso encontrado! Verifique em https://www.pciconcursos.com.br/"
            )
        )

Script bônus

Vamos agendar esses dois scripts utilizando a biblioteca schedule.

1) Primeiro, instale a biblioteca:

pip install schedule

E assim fica:

import schedule
import asyncio
import time
from monitorar_concurso import verificar_concursos
from cotacao_moeda import monitorar_cotacao
from send_msg_telegram import enviar_mensagem


def existe_concurso():
    if verificar_concursos(
        [
            "desenvolvedor",
            "programador",
            "engenheiro de software",
            "tecnologia da informação",
        ]
    ):
        asyncio.run(
            enviar_mensagem(
                "Novo concurso encontrado! Verifique em https://www.pciconcursos.com.br/"
            )
        )


def cotacao_dolar():
    cotacao_atual = monitorar_cotacao()
    if cotacao_atual > 5.3:
        asyncio.run(
            enviar_mensagem(
                f"A cotacao do dolar subiu para {cotacao_atual:.2f} BRL."
            )
        )
    elif cotacao_atual < 5.0:
        asyncio.run(
            enviar_mensagem(
                f"A cotacao do dolar caiu para {cotacao_atual:.2f} BRL."
            )
        )


# Agendar execuções
schedule.every().day.at("17:00").do(existe_concurso)
schedule.every(1).hours.do(cotacao_dolar)

while True:
    schedule.run_pending()
    time.sleep(1)

Agendamos o monitor de concursos para rodar todos os dias às 17:00 e o monitor de cotação para executar de hora em hora.

Conclusão

Certamente que podemos melhorar muito essas automações, mas tome isso como um ponto de partida que você vai incrementando. Por exemplo: as palavras-chaves do monitor de concursos e os limites da cotação de moeda podem ser modificados periodicamente utilizando um arquivo de configuração ou mesmo uma interface de usuário. Usuários avançados podem criar uma API utilizando um framework Python tais como Flask ou FastAPI e assim suas automações ficam rodando sem a necessidade de seu próprio computador estar ligado.

5 Automações Simples para Economizar Tempo e Dinheiro usando Python e APIs

2025-11-08T18:32:00.007-03:00

5 Automações Simples para Economizar Tempo e Dinheiro usando Python e APIs

Tempo de leitura: 10 minutos

Introdução

Você gasta horas repetindo tarefas manuais que poderiam executar sozinhas? Então vejamos como usar Python + APIs para automatizar processos e poupar tempo e dinheiro. Neste artigo você vai aprender 5 scripts práticos e fáceis de implementar — perfeitos para quem não é engenheiro de software, mas quer resultados reais.

Fonte: https://br.freepik.com/

1. Automação #1: Cotação do dólar (ou outra moeda) em tempo real

Por que isso importa

Se você faz negócios internacionais, ou você trabalha com importações, vendas ou orçamentos em moeda estrangeira, saber a cotação atual de uma moeda pode evitar surpresas.

Como fazer

Use uma API de câmbio, por exemplo uma que retorne “USD/BRL” ou outra paridade. Iremos usar AwesomeAPI, que permite até 10 mil requisições mensais gratuitas.
Em Python, use requests.get() para chamar a API, parse o json e extraia a taxa.
Armazene ou mostre a taxa num relatório ou envie uma notificação (e-mail ou Telegram). No próximo post iremos mostrar como enviar notificações pelo Gmail e pelo Telegram.

Esboço de script (exemplo simplificado)

import requests


LIMITE_SUPERIOR = 5.4
LIMITE_INFERIOR = 5.0


def monitorar_cotacao():
    API_URL = "https://economia.awesomeapi.com.br/last/USD-BRL"
    resp = requests.get(API_URL)
    data = resp.json()
    cotacao_dolar = float(data['USDBRL']['bid'])
    return cotacao_dolar


if __name__ == "__main__":
    cotacao_atual = monitorar_cotacao()

    if cotacao_atual > LIMITE_SUPERIOR:
        print(
            "Alerta de Cotação:",
            f"A cotação do dólar subiu para {cotacao_atual:.2f} BRL.")
    elif cotacao_atual < LIMITE_INFERIOR:
        print(
            "Alerta de Cotação",
            f"A cotação do dólar caiu para {cotacao_atual:.2f} BRL.")

Dica para economizar

Agende esse script para rodar uma vez por dia (usando a biblioteca schedule do Python). Se a taxa ultrapassar um valor crítico (ex: R$ 5,40), você recebe um alerta e pode agir antes de fechar negócio.

2. Automação #2: Alerta de gastos ou despesas inesperadas

Por que isso importa

Muitas pessoas não revisam seus gastos com frequência — e uma despesa inesperada pode passar batida ou essa pessoa pode ser surpreendida por um estouro no orçamento. Uma automação simples pode alertar você antes que isso se torne um problema.

Como fazer

Conecte-se à planilha que mostramos no post anterior, onde foi apresentado passo a passo como automatizar suas finanças.
Em Python, filtre transações no período desejado, acima de um valor definido, de determinada categoria ou mesmo o valor total das transações.
Se encontrar valores que extrapolem os limites estabelecidos por você, envie e-mail ou mensagem com aviso.

Esboço de script

import pandas as pd
from automatizar_financas import conectar_google_sheets


MES_ATUAL = "10"
ORCAMENTO_MENSAL = 2000.0  # Exemplo de orçamento mensal


def calcular_despesas():
    client = conectar_google_sheets()
    planilha = client.open("Minhas Finanças Pessoais")
    worksheet = planilha.worksheet("Transações")

    # Obter dados atualizados
    transacoes = worksheet.get_all_records()
    # Converter para DataFrame do pandas
    transacoes_df = pd.DataFrame(transacoes)
    # Filtrar apenas despesas do mês atual
    despesas = transacoes_df[
        (transacoes_df["Tipo"] == "Despesa")
        & (transacoes_df["Data"].str.contains(f"/{MES_ATUAL}/"))
    ]
    total_despesas = despesas["Valor"].sum()
    return total_despesas


if __name__ == "__main__":
    total_despesas = calcular_despesas()
    print(f"Total de despesas no mês atual: R$ {total_despesas:.2f}")
    if total_despesas > ORCAMENTO_MENSAL:
        print("Atenção: Você ultrapassou o orçamento mensal!")
    else:
        print("Você está dentro do orçamento mensal.")

Antes de tudo instale o pandas com:

pip install pandas

Observe que reutilizamos a função conectar_google_sheets(), que conecta à planilha criada no post anterior. Daí lemos os registros, fazemos a conversão da lista para um DataFrame, o que vai facilitar a filtragem dos dados desejados e a própria totalização.

Dica para economizar

Use isso para categorizar “gastos recorrentes + variações”. Se algo aumentou 30%, por exemplo, sobre o mês anterior, você já recebe o alerta e pode renegociar ou cancelar antes que vire padrão.

3. Automação #3: Monitor de preço para compra de um produto

Por que isso importa

Suponha que você deseja adquirir um produto, mas está aguardando um desconto, uma promoção que leve o preço desse produto a um valor viável para você. Ficar na frente da tela aguardando isso acontecer não é uma opção. Uma automação que faça esse trabalho e lhe envie um alerta seria uma mão na roda.

Como fazer

Identifique o endpoint ou API que fornece o preço ou use scraping (se permitido no site alvo).
Em Python, periodicamente consulte esse preço.
Se o valor cair abaixo de um limiar que você definiu, envie alerta para aproveitar a oferta ou negocie.

Esboço de script

from bs4 import BeautifulSoup
import requests


PRECO_ALVO = 200.0


def monitorar_preco(url):
    headers = {
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3"
    }
    response = requests.get(url, headers=headers)
    page_contents = response.text
    doc = BeautifulSoup(page_contents, "html.parser")
    price = doc.select_one(
      "div.ui-pdp-price__second-line span.andes-money-amount__fraction")
    price_cents = doc.select_one(
      "div.ui-pdp-price__second-line span.andes-money-amount__cents")
    final_price = f"{price.text}.{price_cents.text}"
    return float(final_price)


if __name__ == "__main__":
    url = "https://www.mercadolivre.com.br/parafusadeira-furadeira-de-impacto-the-black-tools-profissional-tb-21px-2-baterias-com-maleta-60hz-amarelo/p/MLB30144703#polycard_client=offers&deal_print_id=3f44d512-e52a-4a96-80e5-fb460eadceb4&position=7&tracking_id=01757776-3524-4dab-a168-16eb7c0c96d0&wid=MLB4268042659&sid=offers"
    preco_atual = monitorar_preco(url)
    if preco_atual <= PRECO_ALVO:
        print(
            "Alerta de Preço:",
            f"O preço do produto caiu para R$ {preco_atual:.2f}!")

Primeiramente instale o BeautifulSoup com:

pip install beautifulsoup4

Neste exemplo utilizamos o link de um produto no Mercado Livre. A função monitorar_preco() só funciona no Mercado Livre, dado que cada site tem suas peculiaridades, nomes de classes, tag onde se localiza o preço, etc

Dica para economizar

Combine esse script com envio de mensagem via Telegram ou e-mail. Assim você pode receber uma mensagem “isso está barato agora” e decidir com calma a aquisição.

4. Automação #4: Monitor de concursos públicos para devs

Por que isso importa

Suponha o cenário em que você está batalhando por uma vaga de trabalho e os concursos públicos podem ser uma oportunidade. Se você pudesse receber uma notificação no seu e-mail ou mesmo no Telegram pelo smartphone seria de grande ajuda. Assim você estaria em dia com as publicações de editais.

Como fazer

Uma solução é fazer scraping de sites agregadores de editais. Aqui escolhemos o PCI Concursos.
Em Python, monitore regularmente os anúncios em busca de palavras-chaves como Engenheiro de Software, Desenvolvedor, etc.
Crie um alerta por e-mail ou Telegram quando o script encontrar alguma(s) de suas palavras-chaves alvo.

Esboço de script

import requests
from bs4 import BeautifulSoup


def verificar_concursos(palavras_chave=[]):
    url = "https://www.pciconcursos.com.br/"
    headers = {
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3"
    }
    response = requests.get(url, headers=headers)
    page_contents = BeautifulSoup(response.text, "html.parser")

    noticias = page_contents.find("div", id="noticias_capa")
    # Procure por palavras-chaves na página
    exist = any(
      elemento in noticias.get_text().lower()
      for elemento in palavras_chave)

    return exist


if __name__ == "__main__":
    if verificar_concursos(
        [
            "desenvolvedor",
            "programador",
            "engenheiro de software",
            "tecnologia da informação",
        ]
    ):
        print("Novo concurso encontrado!")

Dica para economizar

Inclua outros sites similares ao PCI Concursos, adicione outros nomes de vagas na lista e agende esse script para rodar a cada 30 dias e, sempre que ele retornar positivo, envie uma notificação.

5. Automação #5: Backup automático de dados críticos

Por que isso importa

Perder dados de clientes, documentos, planilhas ou dashboards pode significar retrabalho ou até risco de perder dinheiro. Fazer backups manuais dá trabalho e pode falhar, principalmente por esquecimento. Automatizar essa tarefa pode ser uma garantia de segurança.

Como fazer

Use API de armazenamento em nuvem (por exemplo: Google Drive API, Dropbox API) ou conexão FTP.
Em Python, selecione os arquivos/diretórios críticos no horário definido.
Faça upload para o serviço de nuvem ou outro local seguro. Opcional: mantenha versionamento ou apague backups antigos automaticamente.

Esboço de script

from zipfile import ZipFile, ZIP_DEFLATED
import dropbox
import pathlib
import os


TOKEN = 'seu access_token aqui'


def criar_backup(diretorio_arquivo, arquivo_backup):
    with ZipFile(arquivo_backup, 'w', ZIP_DEFLATED) as zipf:
        for pasta_atual, subpastas, arquivos in os.walk(diretorio_arquivo):
            for arquivo in arquivos:
                caminho_completo = os.path.join(pasta_atual, arquivo)
                zipf.write(caminho_completo,
                           os.path.relpath(
                             caminho_completo, diretorio_arquivo))


def dropbox_backup(arquivo_backup, token_acesso):
    local_filepath = pathlib.Path(arquivo_backup)
    dropbox_path = f'/{arquivo_backup}'
    dbx = dropbox.Dropbox(token_acesso)
    with local_filepath.open('rb') as f:
        dbx.files_upload(
          f.read(), dropbox_path, mode=dropbox.files.WriteMode('overwrite'))


if __name__ == "__main__":
    criar_backup('../cinco-scripts', 'backup.zip')
    dropbox_backup('backup.zip', TOKEN)
    os.remove('backup.zip')
    print("Backup criado e enviado para o Dropbox com sucesso.")

Neste script precisamos instalar, antes de tudo, o pacote dropbox:

pip install dropbox

A função criar_backup() cria um arquivo compactado da pasta que desejamos salvar, usando o pacote zipfile. A função dropbox_backup() faz o upload do arquivo compactado para nossa conta Dropbox.

Dica para economizar

Obs: os protocolos de segurança de armazenamento em nuvem tem mudado e o Dropbox não permite mais gerar token que não expira. Então essa automação fica dependendo do usuário para obter o token. Portanto, pode-se escolher entre fazer o backup manualmente ou obter o token.

Uma sugestão seria agendar o envio de uma mensagem no Telegram alertando-o para fazer o backup e agendar para um tempinho depois execução do backup. Isso evitaria “descobrir” só depois que perdeu algo valioso.

Como adaptar isso para você

Escolha 1 automação para começar — não tente todas de uma vez.
Use bibliotecas Python simples como requests, pandas e schedule para agendar tarefas.
Documente seu “workflow automático” para que, se você terceirizar ou vender isso como serviço, esteja pronto.
Defina alertas claros (SMS, Telegram, e-mail) para que a automação não fique apenas “rodando” mas entregue valor real.
Meça o tempo/dinheiro que cada automação te economiza. Por exemplo: “economizei 1 h/mês = R$ X” — isso te ajuda a justificar ou escalar.

Conclusão

Automatizar com Python + APIs não exige ser um programador sênior. Com cinco scripts simples — cotação de moeda, alerta de gastos, monitor de preços, monitor de concursos e backup de dados — você já poderá economizar horas, evitar erros e reduzir custos.
Comece pequeno, escale conforme o conforto cresce, e logo você estará mais focado no que importa (criar, vender, crescer) em vez de repetir tarefas manuais.

Como Automatizar suas Finanças Pessoais com Google Sheets e Python

2025-11-03T09:40:00.007-03:00

Como Automatizar suas Finanças Pessoais com Google Sheets e Python

Tempo de leitura: 8 minutos

Obs: Este é o primeiro artigo da nova fase do blog, agora focado em finanças e automação para desenvolvedores.

Manter o controle das finanças pessoais pode ser uma tarefa tediosa e repetitiva. Que tal automatizar uma parte ou até todo o processo, tendo suas receitas, investimentos e gastos atualizados automaticamente? Neste guia prático, iremos mostrar como criar uma planilha atualizada automaticamente usando Google Sheets e Python. O tutorial apresenta uma planilha básica que você poderá melhorar à medida que ganha experiência.

Fonte: https://br.freepik.com

💡 Dica: Este guia assume que você tem conhecimentos básicos de Python e planilhas. Mesmo sem experiência avançada, você conseguirá seguir os passos!

Por que Automatizar suas Finanças?

Economia de tempo: Chega de digitar extrato por extrato
Visão em tempo real: Dados sempre atualizados
Tomada de decisão: Informações precisas para investir melhor
Controle de gastos: Alertas automáticos quando ultrapassar orçamentos

Pré-requisitos

Conta no Google e credenciais no Google Cloud
Python e bibliotecas instaladas
Conhecimento básico de planilhas e programação

Passo a Passo da Automação

1. Estruturando sua Planilha no Google Sheets

Crie uma planilha com as seguintes abas:

📊 Dashboard Principal

Saldo Atual: R$

Receita do Mês: R$

Despesas do Mês: R$

Investimentos: R$

💳 Transações (com as seguintes colunas)

Data	Descrição	Categoria	Valor	Tipo

📈 Investimentos (com as seguintes colunas)

Ativo	Quantidade	Preço Médio	Preço Atual	Valor Investido

2. Ativar APIs do Google Drive e Google Sheets e obter credenciais

O primeiro passo aqui, após logar na sua conta Google, consiste em acessar o Google Cloud e clicar em Console no canto superior direito.

Botão Console no Google Cloud

Em seguida clique no menu e na opção APIs e serviços ou use os botões de acesso rápido. Clique então em Biblioteca no menu e ative Google Drive API e Google Sheets API.

Botão APIs e serviços

Finalmente, ainda na opção APIs e serviços, vá em Credenciais. Se você já tiver uma conta de serviço, clique no e-mail visível no grupo Contas de serviço, a fim de criar uma chave. Se não, clique em + Criar credenciais e Conta de serviço para criar uma.

Contas de serviço

Depois que visualizar a Conta de serviço, clique em Chave e em Adicionar chave. Selecione Criar nova chave, deixe marcado JSON e clique em Criar. Salve o arquivo JSON numa pasta segura no seu computador, dê um nome a ele, por exemplo credenciais.json. Em seguida copie o e-mail na chave client_email do JSON salvo. Ele será usado para compartilhar a planilha no Google Sheets.

Criar uma chave na Conta de serviço

3. Conectando a API do Google Sheets

Primeiramente, instale as bibliotecas que serão usadas no código Python:

pip install gspread pandas google-auth yfinance

Em seguida, escreva a função responsável por fazer a conexão com a API do Goolge Sheets. Note que utilizamos o arquivo credenciais.json que foi obtido na seção anterior:

automatizar_financas.py

import gspread
import pandas as pd
from google.oauth2.service_account import Credentials


def conectar_google_sheets():
    scopes = [
        "https://www.googleapis.com/auth/spreadsheets",
        "https://www.googleapis.com/auth/drive",
    ]

    creds = Credentials.from_service_account_file(
      "credenciais.json", scopes=scopes)

    client = gspread.authorize(creds)
    return client

4. Script para Atualizar Transações Bancárias

Aqui é necessário obter um extrato da sua conta por meio do aplicativo do banco. Após a solicitação você irá receber um e-mail com o extrato em três formatos: PDF, CSV e OFX. Nós iremos utilizar o formato CSV. Dois pontos merecem atenção:

a) Não existe uma estrutura padrão. Cada banco usa nomes de campos diferentes e posições diferentes no arquivo;

b) Pode ser necessário fazer uma limpeza (preparação dos dados) antes de fazer a importação. Checamos isso em dois bancos: Nubank e Inter. Nubank envia um extrato onde os campos são separados por vírgula e o Inter usa ponto e vírgula como separador, além de precisar deletar algumas linhas no início do arquivo.

No nosso exemplo usaremos um extrato obtido do banco Inter, usando o seguinte código:

automatizar_financas.py

import gspread
import pandas as pd
from google.oauth2.service_account import Credentials

# Código anterior vai aqui

def importar_extrato_csv(arquivo_csv, worksheet):
    df = pd.read_csv(
        arquivo_csv,
        sep=";",
        decimal=",",
        encoding="utf-8",
        on_bad_lines="skip",
    )
    for _, row in df.iterrows():
        worksheet.append_row(
            [
                row["Data Lançamento"],
                row["Histórico"] + " " + row["Descrição"],
                "",
                float(row["Valor"].replace(".", "").replace(",", ".")),
                0,
            ]
        )

Esta função deve receber como parâmetros o extrato em CSV e o objeto planilha obtido por meio da conexão com a API Google Sheets.

A função lê o CSV e o converte em um DataFrame, o qual é precorrido e cada uma de suas linhas é adicionado à planilha Google. Os nomes das colunas no DataFrame são definidos pelo CSV fornecido pelo banco Inter. Para um outro banco esses nomes podem ser diferentes.

Juntando essas duas funções com o trecho que vai executar:

automatizar_financas.py

import gspread
import pandas as pd
from google.oauth2.service_account import Credentials


def conectar_google_sheets():
    scopes = [
        "https://www.googleapis.com/auth/spreadsheets",
        "https://www.googleapis.com/auth/drive",
    ]

    creds = Credentials.from_service_account_file(
        "credenciais.json", scopes=scopes)

    client = gspread.authorize(creds)
    return client


def importar_extrato_csv(arquivo_csv, worksheet):
    df = pd.read_csv(
        arquivo_csv,
        sep=";",
        decimal=",",
        encoding="utf-8",
        on_bad_lines="skip",
    )
    for _, row in df.iterrows():
        worksheet.append_row(
            [
                row["Data Lançamento"],
                row["Histórico"] + " " + row["Descrição"],
                "",
                float(row["Valor"].replace(".", "").replace(",", ".")),
                (
                    "Receita"
                    if float(
                        row["Valor"].replace(".", "").replace(",", ".")
                        ) >= 0
                    else "Despesa"
                ),
            ]
        )


if __name__ == "__main__":
    # Conectar à planilha
    client = conectar_google_sheets()
    # Abrir a planilha e a aba desejada (case sensitive)
    planilha = client.open("Minhas Finanças Pessoais")
    sheet = planilha.worksheet("Transações")
    # Importar o extrato CSV para a aba especificada
    importar_extrato_csv(
        "./extratos/Extrato-30-09-2025-a-30-10-2025-CSV.csv", sheet)
    print("Importação concluída com sucesso!")

Atente para os comentários neste trecho. Além da questão de que os nomes das planilhas são case sensitive, o CSV está numa pasta denominada extratos.

5. Atualizando Preços de Investimentos

investimentos.py

from automatizar_financas import conectar_google_sheets
import yfinance as yf


def atualizar_investimentos():
    client = conectar_google_sheets()
    planilha = client.open("Minhas Finanças Pessoais")
    worksheet = planilha.worksheet("Investimentos")

    # Obter dados atualizados
    investimentos = worksheet.get_all_records()

    for i, investimento in enumerate(investimentos, start=2):
        ticker = investimento['Ativo']
        preco_atual = obter_preco_atual(ticker)

        # Atualizar preço atual
        worksheet.update_cell(i, 4, preco_atual)

        # Calcular e atualizar valor total
        quantidade = investimento['Quantidade']
        valor_total = quantidade * preco_atual
        worksheet.update_cell(i, 5, valor_total)


def obter_preco_atual(ticker):
    # Exemplo com API do Yahoo Finance
    ticker_yf = yf.Ticker(ticker + ".SA")
    info = ticker_yf.info
    return info.get('regularMarketPrice', 0.0)


if __name__ == "__main__":
    atualizar_investimentos()
    print("Atualização de investimentos concluída com sucesso!")

Neste módulo utilizamos o pacote yfinance para obter dados das ações, neste caso, o preço atual. O código lê da planilha Investimentos, cada ação, busca seu preço atual e atualiza os valores das células de preço e valor total.

6. Dashboard Automático com Fórmulas

A fim de que os dados sejam resumidos, no Google Sheets, use estas fórmulas na aba Dashboard:

Saldo Atual:

=SOMA(Transações!D:D)

Receita do Mês:

=SOMA(FILTER('Transações'!D2:D; 'Transações'!E2:E="Receita"; MÊS('Transações'!A2:A)=HOJE()))

Despesas do Mês:

=SOMA(FILTER('Transações'!D2:D; 'Transações'!E2:E="Receita"; MÊS('Transações'!A2:A)=HOJE()))

Investimentos:

=SOMA(Investimentos!E:E)

7. Agendando a Execução Automática

Visto que a obtenção do extrato bancário não pode ser automatizada, se agendarmos a atualização das transações bancárias, será necessário que você solicite o extrato antes que a tarefa agenda aconteça. Desse modo vamos mostrar apenas o agendamento da atualização dos investimentos. De toda maneira, com poucas alterações podemos incluir o agendamento das transações.

agendamento.py

import schedule
import time
from datetime import datetime
from investimentos import atualizar_investimentos


def rotina_diaria():
    atualizar_investimentos()
    print(f"Planilha atualizada em {datetime.now()}")


# Agendar execução diária às 18:00
schedule.every().day.at("09:27").do(rotina_diaria)

while True:
    schedule.run_pending()
    time.sleep(1)

Dicas para Personalizar

Adapte às suas necessidades: Adicione categorias específicas do seu estilo de vida
Múltiplas fontes: Conecte com diferentes bancos e corretoras
Backup automático: Configure backup semanal da planilha
Segurança: Mantenha suas credenciais em ambiente seguro

🚀 Próximos Passos:

Adicione gráficos automáticos no Google Sheets
Crie alertas por email
Crie relatórios mensais por email
Integre com Telegram para notificações
Adicione previsões de gastos com machine learning

Conclusão

Com essa automação, você terá suas finanças sempre organizadas e atualizadas, podendo focar no que realmente importa: tomar decisões inteligentes com seu dinheiro.

💡 Dica final: Comece simples e vá incrementando aos poucos. O importante é dar o primeiro passo rumo à liberdade financeira!

Lazarus - Recursos do Editor de Código

2011-08-12T14:37:00.008-03:00

Lazarus - Recursos do Editor de Código

Neste post vamos apresentar alguns dos inúmeros recursos que o Editor de Código oferece aos desenvolvedores. O Editor pode ser configurado via menu em Tools | Options | Editor. Estas opções também podem ser acessadas através do menu de contexto.

O detalhamento das opções e configuração do Editor exige um post específico, portanto não iremos nos ater a isso no momento. Queremos falar de recursos que a ferramenta oferece para facilitar o trabalho do programador.

Syncron

Esta é uma opção onde podemos rapidamente modificar o nome de um identificador em um trecho de código selecionado.

Quando você seleciona um trecho do código (ou o código inteiro), no lado esquerdo do Editor aparece um ícone com uma caneta. Clique nesse ícone ou tecle CTRL + J. A área selecionada muda de cor e o cursor é movido para uma instância do identificador, destacando cada uma de suas ocorrências naquela área. Modifique o identificador e cada ocorrência dele será alterada automaticamente.

Volte a clicar no ícone ou tecle ESC para sair do modo syncron.

O Code Completion é um dos recursos que pode poupar muito tempo de digitação. Dependendo da posição do cursor no Editor, várias funções podem ser chamadas.

Complementação de classe

Se você escreveu uma classe incluindo propriedades e métodos, este recurso irá adicionar o corpo do método, variáveis e métodos de acesso às propriedades, etc. Suponha que você tenha criado a seguinte classe:

TPessoa = class(TObject)
    constructor Create;
    destructor Destroy; override;
    property nome: string;
end;

Posicione o cursor no interior da classe e pressione CTRL + SHIFT + C. O código seguinte será gerado, e o cursor será movido para que o corpo do primeiro método seja digitado.

type

  { TPessoa }

  TPessoa = class(TObject)
  private
    Fnome: string;
    procedure Setnome(AValue: string);
  published
    constructor Create;
    destructor Destroy; override;
    property nome: string read Fnome write Setnome;
  end;

implementation

{ TPessoa }

procedure TPessoa.Setnome(AValue: string);
begin
  if Fnome=AValue then exit;
  Fnome:=AValue;
end;

constructor TPessoa.Create;
begin

end;

destructor TPessoa.Destroy;
begin
  inherited Destroy;
end;

Complementação de declaração de variável

Se o cursor é posicionado em um identificador e for pressionado CTRL + SHIFT + C, é adicionado ao código uma declaração de variável local. Por exemplo, imagine o seguinte código fonte:

procedure TForm1.FormClick(Sender: TObject);
begin
  i := 5;
end;

Posicione o cursor na variável i (antes ou depois) e pressione CTRL + SHIFT + C. O código será modificado e ficará assim:

procedure TForm1.FormClick(Sender: TObject);
var
  i: Integer;
begin
  i := 5;
end;

O tipo da variável é deduzida a partir da expressão.

Message Composer

O Message Composer é uma ferramenta que auxilia na criação de caixas de diálogos, tais ShowMessage, MessageDlg e InputBox. Para isso é necessário instalar o pacote messagecomposerpkg. Vá em Package | Install/Uninstall packages. Na lista Do not install localize e selecione messagecomposerpkg. Clique em Install selection e depois em Save and rebuild IDE. Em seguida clique no botão Continue para confirmar. Após o IDE ser reiniciado uma nova opção será adicionada ao menu Source. Você também pode usar o atalho CTRL + M. Esta opção irá abrir a seguinte janela:

Após escolher o tipo de mensagem, os parâmetros demais opções, confirme em OK e o diálogo selecionado será adicionado no seu código na posição do cursor.

Dicas para funções e procedimentos

Se você não lembra dos parâmetros, ordem, tipos de dados de uma função ou procedimento, digite a mesma e dentro dos parênteses tecle CTRL + SHIFT + ESPAÇO. Irá aparecer uma janela de dica com os argumentos:

À medida que um argumentos é digitado, o próximo fica em destaque na janela. Um botão à direita permite colar os parâmetros no código fonte.

Templates

Templates são modelos que podem ser inseridos no código. Por exemplo, suponha que você deseja inserir um comando case no seu código. Digite casee no ponto onde deseja inserir e tecle CRTL + J. Será inserido o seguinte código, e o cursor será posicionado no local onde deve ser inserida a variável do comando.

Existem vários modelos prontos, mas você pode criar os seus próprios templates usando a opção Tools | Code Templates. Na janela que será aberta você usará o botão Add para adicionar novo modelo.

Clique aqui para ver um rápido tutorial de como criar novos modelos. Por enquanto é isso que temos. Aproveite os recursos e explore mais possibilidades com o Lazarus

Lazarus - Usando Dicionários de Dados

2011-07-23T08:40:00.007-03:00

Lazarus - Usando Dicionários de Dados

Nos dois posts anteriores:
Lazarus - O Lazarus Data Desktop e
Lazarus - Dicionário de Dados
estudamos a ferramenta Lazarus Data Desktop e como criar dicionários de dados. Neste artigo iremos mostrar como usar os dicionários nas aplicações desenvolvidas usando Lazarus.
Como já falamos, um dicionário de dados descreve entre outras coisas os atributos dos campos das tabelas de um esquema de banco de dados. E essa descrição, também chamada de metadados, pode ser usada nas aplicações para evitar que tenhamos que repetir essas definições em cada DataSet. Assim, vamos supor que já exista um dicionário de dados criado para um tabela chamada PRODUTO. E vamos mostrar como usar o dicionário de dados em tempo de execução e como aplicá-lo em tempo de desenvolvimento.
O primeiro passo é o mesmo necessário para acessar qualquer tabela sem usar o recurso do dicionário de dados. Supondo que estejamos usando ZeosLib, coloque todos os componentes que são precisos, no Data Module: ZConnection, ZQuery e um DataSource. Faça todas as configurações exigidas. Agora crie os campos persistentes TFields para a ZQuery - este é um procedimento obrigatório para o funcionamento do dicionário de dados. Dê um duplo clique na ZQuery e você verá uma pequena janela como na figura abaixo:

Clique no botão com o sinal de + ou pressione CTRL + INS para inserir os campos. Uma nova janela mostrando todos os campos da tabela correspondente será mostrada, como a figura a seguir:

Selecione todos os campos e pressione o botão Create.

Usando dicionário de dados em run-time

Uma maneira de usar o dicionário de dados em tempo de execução é inserir o código, por exemplo, no evento OnCreate do Data Module. A classe TFPDataDictionary está localizada na unit fpdatadict. Portanto, é necessário declarar esta unit na cláusula uses no módulo onde será instanciada TFPDataDictionary. Assim, nosso código poderá ficar assim:

procedure TdmData.DataModuleCreate(Sender: TObject);
var
  Dict : TFPDataDictionary;
begin
  Dict := TFPDataDictionary.Create;
  // carrega o arquivo do dicionário de dados
  Dict.LoadFromFile('produto.fpd');
  // aplica o dicionário ao DataSet
  Dict.ApplyToDataset(queProduto);
  // libera a memória usada pelo dicionário de dados
  Dict.Free;
end;

Num form você pode inserir um TDBGrid, onde serão mais facilmente visualizados os efeitos que desejamos. Associe essa grade ao DataSource que está ligado ao DataSet onde foi aplicado o dicionário.
Agora execute o programa e você poderá constatar que todas as definições feitas no dicionário de dados serão assumidas pelos TFields que foram criados.

Usando dicionário de dados em tempo de projeto

Neste caso, o primeiro passo é registrar no projeto o dicionário desejado. Isso é feito usando a opção de menu Project > Data Dictionary > Set ... Quando selecionar este item de menu um diálogo será aberto:

Marque a caixa Use Data dictionary for this project. E selecione o dicionário de dados desejado. Confirme pressionando OK.
Agora localize o DataSet e clique com o botão direito sobre ele. Selecione o item Data dictionary e depois em Apply.

Isso irá aplicar o dicionário ao DataSet, da mesma forma que fizemos usando código. Agora podemos executar o programa e aproveitar o recurso.
Post escrito tendo como referência o livro Lazarus - the Complete Guide, publicado pela Blaise Pascal Magazine.

Lazarus - Dicionários de Dados

2011-07-10T23:22:00.006-03:00

Lazarus - Dicionários de Dados

Dicionários de dados são repositórios com metadados sobre bancos de dados, que descrevem a estrutura básica de um esquema de banco de dados. Num dicionário de dados as seguintes informações são armazenadas: as tabelas e os campos correspondentes, e os índices existentes nas tabelas. Além disso, os dicionários de dados contém atributos que definem como o conteúdo dos campos devem ser visualizados: número de casas decimais, o rótulo, a dica (hint) mostrada, tamanho do campo, entre outros.
Um dicionário de dados pode ser usado por uma aplicação Lazarus para definir as propriedades dos objetos TField; pode ser usado para criar comandos SQL, por exemplo, para criar o banco de dados descrito; e, a partir da comparação entre dois dicionários, as diferenças entre eles podem ser usadas para criar um script de atualização.
Os dicionários de dados podem ser mantidos usando o Lazarus Data Desktop, que começamos a descrever no post Lazarus - o Lazarus Data Desktop. Usando esta ferramenta podemos criar um dicionário novinho em folha ou importá-lo a partir de um banco de dados existente.

Criando um Dicionário de Dados

Para criar um novo dicionário clique no botão correspondente na barra de ferramentas conforme mostra a figura, ou tecle CTRL + N.

Isso irá criar uma nova aba. Clique com o botão direito no interior da aba e em seguida na opção New Table, ou tecle CTRL + T, para criar uma nova tabela. Digite o nome da tabela na caixa de diálogo e confirme.
Agora clique com o botão direito sobre o nome da tabela recém-criada e escolha a opção New Field. Digite o nome do campo e confirme. Um novo campo será criado e um formulário para definir as propriedades do campo será aberto no lado direito da interface, como podemos ver na figura abaixo.

Algumas propriedades que podem ser definidas, entre outras:
DisplayName - rótulo do campo que poderá ser visualizado em uma TDBGrid, por exemplo;
DisplayWidth - tamanho com que o campo será exibido;
FieldType - tipo de dado do campo;

Após criar todas as tabelas e campos, tecle CTRL + S para salvar.

Gerando comandos SQL a partir do Dicionário

Para gerar os comandos SQL pressione o botão correspondente conforme mostra a figura abaixo ou tecle CTRL + G.

Essa ação irá abrir um novo formulário. Escolha a tabela para a qual deseja gerar os comandos SQL. Na lista Key fields selecione o(s) campo(s) que será chave primária. Na lista Select/Update/Insert fields selecione o(s) campo(s) que serão usados nos comandos SELECT, UPDATE e INSERT. Pressione o botão Generate SQL. Clique em cada uma das abas para ver os comandos gerados. Na figura seguinte mostramos o comando CREATE TABLE que foi gerado.

Importando o Dicionário de Dados

Se já tivermos um banco de dados criado, podemos criar o dicionário a partir dele - processo que é chamado engenharia reversa.
Inicialmente crie uma conexão para o banco de dados existente conforme mostramos em Lazarus - o Lazarus Data Desktop. Em seguida selecione no menu Dictionary > Import > From connection. As conexões criadas na ferramenta estarão disponíveis nessa opção. Escolha aquela para a qual você precisa criar o dicionário.
Uma caixa de diálogo será aberta mostrando as tabelas do esquema. Selecione as tabelas desejadas, deixe marcada a caixa Update existing tables para atualizar tabelas que já existem e confirme.

Se houver um dicionário ativo na ferramenta, você será questionado se deseja atualizar ou criar um novo. Clique CTRL + S para salvar o dicionário. Os dicionários de dados são salvos com a extensão .fpd. Você pode visualizar o arquivo de dicionário de dados usando qualquer programa que abre arquivos texto.
Fica para o próximo post a utilização de dicionários de dados em aplicações Lazarus.
Post escrito tendo como referência o livro Lazarus - the Complete Guide, publicado pela Blaise Pascal Magazine.

Lazarus - O Lazarus Data Desktop

2011-07-04T14:58:00.007-03:00

Lazarus - O Lazarus Data Desktop

Se em suas aplicações você utiliza diversos bancos de dados, é provável que também precise de uma ferramenta específica para cada SGBD, com a finalidade de criar tabelas, criar comandos DML e DDL, entre outros. A fim de centralizar todas as tarefas do desenvolvedor no Ambiente de Desenvolvimento, o Lazarus oferece o Lazarus Data Desktop. Também chamado Database Desktop, esta ferramenta dispõe de vários recursos, dentre os quais destacamos:

Acesso a todos os bancos de dados suportados pelo Lazarus;
Criação de um dicionário de dados onde as propriedades de TFields podem ser armazenadas;
Criação de comandos DDL e DML a partir do dicionário de dados;
Consulta à tabelas;
Exportação de dados de tabelas para diversos formatos: XML, JSON, CSV, entre outros.

Para usar esta ferramenta. primeiramente é necessário compilá-la. Ela está localizada em tools/lazdatadesktop, no diretório home do Lazarus. Abra então o projeto lazdatadesktop e compile-o.
Para integrar a ferramenta ao IDE, abra e instale o pacote lazDataDict, localizado no diretório components/datadict. Após isso o IDE será estendido em três novas opções:

Um novo item de menu será registrado no menu Project - com o nome Data Dictionary. Esta opção irá permitir que escolhamos um dicionário de dados para o projeto;
No menu Tools será acrescentado o item de menu Database Desktop, que executa o Lazarus Data Desktop;
Finalmente no Form Designer, um novo item é registrado no menu local que pode ser usado para aplicar o dicionário de dados a um TDataset - o item de menu Data Dictionary.

Vejamos então como utilizar o Lazarus Data Desktop.

Conectando-se a bancos de dados

Para fazer uma conexão use a opção de menu Connections > New connection, como mostra a figura abaixo:

Esta ação abrirá uma caixa de diálogo onde você irá escolher o banco de dados:

Selecione o banco de dados e você será levado a um novo diálogo para informar os dados da conexão:

Após informar os dados e confirmar será solicitado um nome para a conexão. Confirme também, após informar o nome e será adicionada uma nova aba ao ambiente com as informações da conexão. No lado direito da tela existe a aba Run Query, que possibilita executar uma consulta e exportar o resultado da consulta, entre outros recursos.

Exportando dados de uma tabela

Para exportar os dados resultantes de uma consulta, use o botão Export this data que será habilitado após a execução bem sucedida de uma Query. Em seguida escolha o tipo de arquivo, por exemplo CSV, e confirme. Então será mostrado um diálogo onde se pode escolher os campos da tabela a serem exportados, o caminho e o nome do arquivo destino e opções de formatação, conforme pode ser visto na figura a seguir.

Depois de confirmar o arquivo exportado será criado.

Gerando código Free Pascal

Outro recurso importante do Lazarus Data Desktop é a criação de código em Free Pascal. Pode-se gerar código quando estamos visualizando o resultado de uma Query ou quando estamos examinando a definição de uma tabla no dicionário de dados.
Os códigos que podem ser gerados são:

Uma constante string a partir do comando SQL quando se está visualizando o resultado de uma consulta;
O código para criar uma tabela DBF a partir dos dados que estão sendo mostrados;
Uma classe Object Pascal e suas propriedades baseados em um Dataset e seus campos;
Uma declaração de classe tiOPF para usar com Object Persistence Framework.

Por exemplo, na aba Run Query, após executar uma consulta, clique no botão Create pascal code for this data. Escolha em seguida a opção Simple object/collection for the data. Será aberto o seguinte diálogo:

Nessa tela você define o caminho e nome do arquivo onde deseja salvar o código e os campos da tabela que serão propriedades da classe. Para cada campo da tabela é possível definir propriedades, bem como definir algumas propriedades da própria classe na aba Options. Confirme e uma tela com o código gerado será aberta, conforme mostra a figura seguinte:

Apesar de ter um botão Save, isso não será mais necessário, pois o código já está salvo no arquivo informado na tela anterior.
No próximo post veremos os procedimentos para criar dicionários de dados no Lazarus Data Desktop e como utilizá-los em nossas aplicações de banco de dados.
Post escrito tendo como referência o livro Lazarus - the Complete Guide, publicado pela Blaise Pascal Magazine.

Free Pascal - Usando TList

2011-06-01T11:42:00.006-03:00

Free Pascal - Usando TList

A classe TList é usada para gerenciar uma coleção de ponteiros, com a grande vantagem de ser dinâmica. Ela dispõe de métodos para fazer busca na lista e ordenar os elementos, entre outros. No exemplo abaixo fazemos uso de alguns desses métodos.

unit Unit1;

{$mode objfpc}{$H+}

interface

uses
  Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, StdCtrls;

type
  TContato = class
    private
      NomeContato     : String;
      TelefoneContato : String;

    public
      property Nome : String
          read NomeContato;
      property Telefone : String
          read TelefoneContato;

      constructor Create(const pNomeContato       : String;
                         const pTelefoneContato   : String);
  end;

  { TfrmTlist }

  TfrmTlist = class(TForm)
    Button1: TButton;
    ListBox1: TListBox;
    procedure Button1Click(Sender: TObject);
  private
    { private declarations }
    Agenda : TList;

    procedure MostraAgenda;
  public
    { public declarations }
  end;

var
  frmTlist: TfrmTlist;

implementation

{$R *.lfm}

constructor TContato.Create(const pNomeContato      : String;
                             const pTelefoneContato : String);
begin
  self.NomeContato     := pNomeContato;
  self.TelefoneContato := pTelefoneContato;
end;

function comparaPorNome(Item1 : Pointer; Item2 : Pointer) : Integer;
var
  contato1, contato2 : TContato;
begin
  contato1 := TContato(Item1);
  contato2 := TContato(Item2);

  if      contato1.Nome > contato2.Nome
  then Result := 1
  else if contato1.Nome = contato2.Nome
  then Result := 0
  else Result := -1;
end;

procedure TfrmTlist.Button1Click(Sender: TObject);
var
  contato : TContato;

begin
  Agenda := TList.Create;

  contato := TContato.Create('Nádia Alves', '3523-0001');
  Agenda.Add(contato);
  contato := TContato.Create('Célio Silva', '3524-0000');
  Agenda.Add(contato);

  Agenda.Add(TContato.Create('Hélio Costa', '3320-1000'));
  Agenda.Add(TContato.Create('Aldo Sousa', '3321-0001'));

  MostraAgenda;
  ShowMessage('Ordenando pelo nome. Pressione OK');
  Agenda.Sort(@comparaPorNome);

  MostraAgenda;
  ShowMessage('Inserindo novo contato. Pressione OK');
  Agenda.Insert(2, TContato.Create('Luis Gonzaga', '3325-4000'));
  MostraAgenda;
  ShowMessage('Excluindo um contato. Pressione OK');
  Agenda.Delete(4);
  ShowMessage('Pressione OK');
  Agenda.free;
end;

procedure TfrmTlist.MostraAgenda;
var
  i : Integer;
begin
  ListBox1.Items.Clear;
  for i := 0 to Agenda.Count-1 do
  begin
    ListBox1.Items.Add(TContato(Agenda[i]).Nome+' - '+
                      (TContato(Agenda[i]).Telefone));
  end;
end;

end.

No exemplo criamos uma classe Contato que será usada para povoar um TList que denominamos Agenda. Um TListBox é usado para apresentar os dados do TList.
Nas linhas que vão de 74 a 95 é onde acontece tudo que pretendemos mostrar. Inicialmente o TList é criado. Em seguida, são criados vários objetos Contato, que são adicionados à Agenda utilizando o método Add(). Este método sempre adiciona um objeto no fim da lista.
Após isso chamamos o método MostraAgenda, que foi criado para visualizar os dados da Agenda no TListBox. Na linha 86 há uma chamada ao método Sort(), que recebe como argumento o método comparaPorNome(). Aqui cabe uma explicação mais detalhada.
A ordenação de uma lista de objetos não é uma coisa tão natural como ordenar números inteiros ou strings. Como sabemos um objeto tem vários campos e por isso precisamos definir qual o critério que será usado para decidir que um objeto A é maior, menor ou igual a um outro objeto B. Por este motivo o método Sort() deve receber como parâmetro uma variável procedural, ou seja, um método que estabelece o critério de ordenação.
Dessa forma, foi criado o método comparaPorNome(), que recebe os ponteiros dos dois objetos a serem comparados. Tal método deve retornar -1 se o primeiro objeto for menor que o segundo, 1 se for maior e 0 se forem iguais. No nosso exemplo definimos que dois Contatos são iguais quando tem nomes iguais. Leia mais sobre variáveis procedurais no post Free Pascal - Variáveis Procedurais. Deve-se ressaltar que o Free Pascal define apenas como deve ser a assinatura do método que ele espera receber em Sort(). A implementação cabe ao desenvolvedor.
Na linha 90 um novo objeto é inserido na posição 2 do TList. Note que a primeira posição é 0.
Usamos o método Delete() para deletar um objeto em uma determinada posição. Na linha 93 excluímos o objeto da posição 4.
Quando a TList não é mais necessária, liberamos a memória usada chamando Free. Para criar uma lista de strings prefira usar TStrings ou sua descendente TStringList.

Lazarus - Acessando banco de dados com SQLdb - Parte III

2011-05-15T17:22:00.008-03:00

Lazarus - Acessando banco de dados com SQLdb - Parte III

Muita coisa mudou no Lazarus desde que começamos a dedicar este blog à divulgação deste poderoso IDE. Quando iniciamos usávamos a versão 0.9.28 e publicamos dois artigos voltados para o uso do conjunto de componentes SQLdb:

Lazarus - Acessando banco de dados com SQLdb - Parte I
Lazarus - Acessando banco de dados com SQLdb - Parte II

Hoje estamos com a versão 0.9.31. Neste post iremos apresentar algumas mudanças para melhor na utilização desses componentes.

Referências aos campos de uma tabela - criação de TFields

Para criar os TFields ainda é necessário que a TSQLQuery esteja ativa. Dê um duplo clique na TSQLQuery e você verá uma janela como esta:

Esta janela oferece uma barra de ferramentas bastante intuitiva. O botão adicionar irá abrir uma nova janela onde você poderá selecionar os campos da tabela que se deseja adicionar. Após selecionar os campos pressione o botão Create. O botão novo campo permite criar um campo de dado, calculado ou lookup. O uso desse botão irá abrir a seguinte janela:

Aqui você escolhe o tipo do campo em Field Type. Em Field properties podemos definir os valores das propriedades do campo. Depois confirme tudo pressionando Ok. Esteja sempre atento que as tabelas envolvidas na criação dos campos devem estar abertas.
Note também que esse procedimento irá criar variáveis do tipo TField, que podem ser usadas no código do nosso programa. Essas variáveis são criadas abaixo do Data Module conforme podemos ver na figura:

A partir disso, podemos acessar os campos da tabela usando essas variáveis, lembrando que elas são objetos. Veja alguns exemplos de utilização desses objetos:

queCidadeidcidade.Value;  // lê o valor do campo, inteiro nesse caso
queCidadeidcidade.AsString;  // lê o valor do campo convertido para string

Criação de TFields não é uma novidade. Isso já existia nas versões anteriores. Apenas ficou um pouco mais intuitivo e fácil manipular a criação desses objetos.

Referência aos parâmetros de um comando SQL

Como sabemos, é possível escrever comandos SQL utilizando parâmetros. Um exemplo é mostrado no código abaixo:

procedure TfrmConsCidade.btnPesquisarClick(Sender: TObject);
begin
  with dmDados.queConsCidade do
  begin
    Close;
    SQL.Clear;
    if (rgCampo.ItemIndex = 0) then
    begin
      // pidcidade é um parâmetro
      SQL.Add('select * from cidade where idcidade = :pidcidade');
      // atribuição do valor do parâmetro
      ParamByName('pidcidade').Value := StrToInt(edValor.Text);
      //Params[0].Value := StrToInt(edValor.Text);
    end
    else
    begin
      SQL.Add('select * from cidade where nome like :pnome');
      ParamByName('pnome').Value := edValor.Text + '%';
    end;
    Open;
  end;
end;

Em versões anteriores não havia o método ParamByName(). O acesso a um parâmetro era feito usando Params[]. Isso é mostrado na linha de código 13, que aparece comentada. O uso de ParamByName() torna o código mais legível.
O SQLdb melhorou muito, mas ainda aconselhamos o uso de ZeosLib.

Free Pascal - Variáveis Procedurais

2011-05-02T00:24:00.008-03:00

Free Pascal - Variáveis Procedurais

Depois de um longo tempo afastado do blog, estamos retornando. Iremos iniciar uma série de artigos dedicados às estruturas de dados do Free Pascal. Mas antes de iniciar é necessário uma breve introdução a variáveis procedurais.
Variáveis procedurais ou tipos procedurais são um recurso do Free Pascal que permite armazenar métodos, funções e procedimentos em variáveis. Tais variáveis podem ser normalmente tratadas, passando-as como parâmetros e chamando os métodos quando for necessário.
Para exemplificar o uso deste recurso vejamos como declarar um tipo procedural:

type
  TFuncaoSemParametro = function(): String;
  TFuncaoComParametro = function(x: String): String;

O primeiro exemplo declara um tipo que armazena um função que não recebe argumentos. O segundo exemplo declara um tipo que armazena uma função que recebe parâmetros.
Tipos procedurais também podem ser declarados de mais duas maneiras, como pode ser visto abaixo. O primeiro declara um tipo para armazenar um procedimento e o segundo armazena um método de uma classe:

type
   TProcedimento = procedure;
   TMetodo = procedure of Object;

Prosseguindo então com nosso exemplo, em seguida iremos declarar as funções:

function AloMundo: String;
begin
  Result := 'Alo Mundo';
end;

function AloNovamente(S: String): String;
begin
  Result := 'Alo ' + S;
end;

Essas duas funções serão usadas como argumentos nas chamadas aos dois procedimentos seguintes, que recebem como parâmetros os tipos procedurais declarados.

procedure Primeiro(f: TFuncaoSemParametro);
begin
  WriteLn(f());
end;

procedure Segundo(f: TFuncaoComParametro);
begin
  WriteLn(f('Novamente'));
end;

Observe que tanto o procedimento Primeiro, quanto o procedimento Segundo executam a função que recebem como parâmetro. As funções chamadas irão retornar Strings que serão escritas no console através de writeln.
Para testar a funcionalidade apenas chame os procedimentos assim:

Primeiro(@AloMundo);
Segundo(@AloNovamente);

O símbolo @ converte a variável em um ponteiro. É desta forma que a função é passada como parâmetro.
É importante observar que o compilador verifica se a função ou o procedimento que está sendo passado como parâmetro corresponde exatamente ao esperado, ou seja, possui os mesmos parâmetros, o mesmo tipo de retorno, etc.
O mecanismo usado pelos eventos de componentes da biblioteca do Lazarus é exatamente este. Veja como pode ser criado um componente dinamicamente e como atribuir um método a um evento de um TButton no post Lazarus - Criando componentes em run-time.
A seguir o código completo da aplicação console:

program procvar;

{$mode objfpc}{$H+}

uses
  {$IFDEF UNIX}{$IFDEF UseCThreads}
  cthreads,
  {$ENDIF}{$ENDIF}
  Classes
  { you can add units after this };
type
  TFuncaoSemParametro = function(): String;
  TFuncaoComParametro = function(x: String): String;

function AloMundo: String;
begin
  Result := 'Alo Mundo';
end;

function AloNovamente(S: String): String;
begin
  Result := 'Alo ' + S;
end;

procedure Primeiro(f: TFuncaoSemParametro);
begin
  WriteLn(f());
end;

procedure Segundo(f: TFuncaoComParametro);
begin
  WriteLn(f('Novamente'));
end;

{$R *.res}

begin
  Primeiro(@AloMundo);
  Segundo(@AloNovamente);
  ReadLn;
end.

Atualizado em 03/05/2011.

Lazarus – Herança de form e criação de componentes em run-time

2010-10-07T17:45:00.008-03:00

Lazarus – Herança de form e criação de componentes em run-time

Neste post vamos mostrar como criar um formulário de cadastro, independente da tabela do banco de dados. A idéia é que, ao abrir o formulário, um trecho de código identifica cada campo da tabela, instancia um TDBEdit para esse campo e ainda o identifica com um TLabel. Além do mais esse código será implementado em um formulário pai. Cada formulário de cadastro será derivado – ou herdado – deste. Nosso demo terá um form principal que chamará o form de cadastro, o form pai onde todas as ações irão acontecer, um form de cadastro derivado e um Data Module.
No Data Module colocamos os componentes de acesso ao banco de dados. Para isso iremos utilizar ZeosLib com banco de dados PostgreSQL. Coloque então um TZConnection para conectar ao seu banco de dados e o configure adequadamente. Coloque também uma TZQuery e um TZUpdateSQL. Consulte o post Lazarus – Conectando PostgreSQL com ZeosLib se tiver dúvida de como fazer essas definições. Não coloque TDataSource no Data Module. Iremos colocá-lo no form pai.

O form Pai

Já existe um form na aplicação. Vamos inserir um novo form e deixar esse primeiro para ser o principal. No novo form vamos criar a propriedade Query conforme mostra o código abaixo. Inclua a unit ZDataset na cláusula uses.

private
    { private declarations }
    fQuery: TZQuery;
    function GetQuery: TZQuery;
    procedure SetQuery(NewQuery: TZQuery);
  public
    { public declarations }
    property Query: TZQuery read GetQuery write SetQuery;
  end;

var
  frmDinamico: TfrmDinamico;
  vetorCampos: array of TDBEdit;
  vetorLabel: array of TLabel;

implementation

{$R *.lfm}

procedure TfrmDinamico.FormShow(Sender: TObject);
var
   Coluna : integer;
   NomeColuna : TDBEdit;
   NomeLabel : TLabel;
   Topo : integer;
begin
   Topo := 65;
   dsTabela.DataSet := fQuery;
   fQuery.Open;
   SetLength(vetorCampos, fQuery.FieldCount);
   SetLength(vetorLabel, fQuery.FieldCount);
   for Coluna := 0 to fQuery.FieldCount - 1 do
   begin
     NomeColuna := TDBEdit.Create(Self);
     NomeColuna.Parent := Self;
     NomeColuna.Left := 105;
     NomeColuna.Top := Topo;
     NomeColuna.Width := 15 + fQuery.Fields[Coluna].DisplayWidth * 7;
     NomeColuna.DataSource := dsTabela;
     NomeColuna.DataField := fQuery.Fields[Coluna].FieldName;
     NomeColuna.Tag := Coluna;
     Topo := Topo + 25;
     NomeColuna.Visible := True;
     NomeColuna.Name := 'DBEdit' + IntToStr(Coluna);
     vetorCampos[Coluna] := NomeColuna;

     NomeLabel := TLabel.Create(Self);
     NomeLabel.Parent := Self;
     NomeLabel.Left := 5;
     NomeLabel.Top := NomeColuna.Top - NomeLabel.Height;
     NomeLabel.Caption := fQuery.Fields[Coluna].DisplayName;
     NomeLabel.Tag := Coluna;
     NomeLabel.Visible := True;
     NomeLabel.Name := 'Label' + IntToStr(Coluna);
     vetorLabel[Coluna] := NomeLabel;
   end;
   if Topo + 25 > 445 then
      Height := 445
   else
      Height := Topo + 25;

end;

procedure TfrmDinamico.FormClose(Sender: TObject; var CloseAction: TCloseAction
  );
begin
  fQuery.Close;
  CloseAction := caFree;
end;

function TfrmDinamico.GetQuery: TZQuery;
begin
  Result := fQuery;
end;

procedure TfrmDinamico.SetQuery(NewQuery: TZQuery);
begin
  fQuery := NewQuery;
end;

Implemente os métodos GetQuery e SetQuery conforme mostrado no código. Na seção var declaramos dois arrays dinâmicos para receber os objetos TDBEdit e TLabel. Agora vamos analisar com mais detalhes o código do evento OnShow. É nesse código que serão criados os objetos em tempo de execução, de acordo com os campos da tabela. No post Lazarus - Criando componentes em run-time nós mostramos como criar componentes em tempo de execução.
Inicialmente no método nós definimos o tamanho dos arrays de acordo com o número de campos da tabela usando o procedure SetLength. Em seguida, dentro de um for que percorre os campos da tabela, é criado um TDBEdit e um TLabel para cada campo. Cada componente é guardado em seu array correspondente. Depois disso é verificada a necessidade de se aumentar a altura do form para que ele possa mostrar todos os componentes criados. Essa verificação é feita através da variável Topo que guarda a posição vertical de cada componente. Como o nosso form é dinâmico, nós liberamos a memória ocupada por ele assim que o mesmo for fechado.

Herdando o form Pai

Depois disso vamos criar o form de cadastro propriamente dito. Para isso selecione o menu File | New e clique em Inherited Component. Na caixa da direita irão aparecer os forms que podem ser herdados. Escolha o form Pai que foi criado anteriormente e pressione OK. Um novo form será criado com todos os membros do form Pai. Agora selecione a opção de menu Project | Project Options. Clique em Forms e transfira o form Filho para a caixa da direita. Isso determina que o form Filho será instanciado em tempo de execução. Para que tudo funcione perfeitamente no form Filho, devemos implementar os métodos herdados e informar a palavra chave inherited. No nosso caso precisamos implementar apenas os método dos eventos OnShow e OnClose, como mostra o código abaixo.

procedure TfrmCidade.FormShow(Sender: TObject);
begin
   inherited
end;

procedure TfrmCidade.FormClose(Sender: TObject; var CloseAction: TCloseAction);
begin
   inherited
end;

Para testar nosso demo, vamos ao form principal. Coloque um botão e escreva o seguinte código no evento OnClick.

if TfrmCidade(Application.FindComponent('frmCidade')) = nil then
  frmCidade := TfrmCidade.Create(Application);
frmCidade.Query := dmDados.queCidade;
frmCidade.Show;

Estamos supondo que o nome do form Filho é frmCidade, que o nome do Data Module é dmDados e que a TZQuery no Data Module chama-se queCidade. Pronto você pode executar o programa e pressionar o botão. Você terá uma tela assim:

Você pode agora repetir esse procedimento para todas as tabelas que precisem de formulários de cadastro. Bem, certamente não é um form de cadastro perfeito, pois todos os campos são definidos com TDBEdit, mas a partir daqui você pode tentar vôos mais altos.

Lazarus - AutoCommit no ZeosLib com PostgreSQL

2010-09-27T21:04:00.012-03:00

Lazarus - AutoCommit no ZeosLib com PostgreSQL

Por padrão, o PostgreSQL trata cada comando SQL como sendo executado dentro de uma transação. Ou seja, cada comando DML (INSERT, UPDATE ou DELETE) tem um comando de início de transação (BEGIN) e um comando COMMIT – caso seja bem sucedido – executados implicitamente antes e depois. Para a execução de múltiplos comandos DML isso leva a um overhead. Desta forma, sugere-se fortemente envolver todos os comandos DML em uma única transação – se a lógica da sua aplicação permitir. Para demonstrar esta recomendação fizemos um teste simples. Escrevemos um pequeno programa para inserir 5.000 linhas em uma tabela. Primeiro fizemos o teste com o controle de transação padrão - cada uma das 5.000 linhas tem seu próprio BEGIN e COMMIT - e depois modificamos o código para controlar a transação manualmente. Neste último teste todas as 5.000 linhas são inseridas dentro de uma única transação.
Para nosso teste usamos ZeosLib. Por padrão o ZeosLib também opera no modo Auto-Commit, ou seja, cada comando é executado no contexto de uma transação. Não mostraremos aqui como conectar ao PG usando Zeos, pois isso já foi apresentado no post Lazarus - Conectando PostgreSQL com ZeosLib. Vejamos o primeiro teste. A unit Dateutils deve ser incluida na cláusula uses para poder usar a função
MilliSecondsBetween(). dbBanco é um ZConnection, dmDados é um Data Module e queCidade uma ZQuery.

var
  i: integer;
  a, b: TDateTime;
begin
  dmDados.queCidade.SQL.Clear;
  dmDados.queCidade.SQL.Add('insert into cidade values (:id, :nome)');
  a := time;
  for i := 1 to 5000 do
  begin
    dmDados.queCidade.ParamByName('ID').Value:= i;
    dmDados.queCidade.ParamByName('NOME').Value:='SANTAREM';
    dmDados.queCidade.ExecSql;
  end;
  b := time;
  ShowMessage(IntToStr(MilliSecondsBetween(b,a)));
end;

Neste primeiro código o tempo médio de inserção das 5.000 linhas foi de 11,6 segundos. Alteramos então nosso código para que todas as linhas fossem inseridas dentro de uma única transação. Para isso chamamos StartTransaction antes de iniciar os INSERTs. Observe o código abaixo.

var
  i: integer;
  a, b: TDateTime;
begin
  a := time;
  dmDados.queCidade.SQL.Clear;
  dmDados.queCidade.SQL.Add('insert into cidade values (:id, :nome)');
  dmDados.dbBanco.StartTransaction;
  for i := 1 to 5000 do
  begin
    dmDados.queCidade.ParamByName('ID').Value:= i;
    dmDados.queCidade.ParamByName('NOME').Value:='SANTAREM';
    dmDados.queCidade.ExecSql;
  end;
  dmDados.dbBanco.Commit;
  b := time;
  ShowMessage(IntToStr(MilliSecondsBetween(b,a)));
end;

Neste caso o tempo médio de execução do código foi de 2,9 segundos. Um ganho de tempo considerável em relação à execução em modo padrão.
Fizemos também um teste usando TZUpdateSQL, implementado de acordo com o post citado acima. O código é apresentado em seguida e o tempo médio de execução foi de 3,8 segundos. Um desempenho um pouco pior do que o teste anterior.

var
  i: integer;
  a, b: TDateTime;
begin
  a := time;
  dmDados.queCidade.Open;
  dmDados.dbBanco.StartTransaction;
  for i := 1 to 5000 do
  begin
    dmDados.queCidade.Insert;
    dmDados.queCidade.FieldByName('ID').Value := i;
    dmDados.queCidade.FieldByName('NOME').Value:='SANTAREM';
    dmDados.queCidade.Post;;
  end;
  dmDados.dbBanco.Commit;
  b := time;
  ShowMessage(IntToStr(MilliSecondsBetween(b,a)));
end;

Estes teste foram feitos em Windows e servidor de BD e cliente rodando na mesma máquina. Certamente se você executar esses testes em outro ambiente, os tempos serão diferentes, mas comparativamente você deverá chegar à mesma conclusão.
Sabe-se que uma falha no sistema, enquanto uma transação estiver ativa, causa a execução de um ROLLBACK pelo SGBD, fazendo com que todas as atualizações feitas a partir do BEGIN sejam canceladas. Portanto, use esta recomendação com cautela e bom senso. Longas transações ativas estão sujeitas a perdas de dados muito maiores que transações curtas, em caso de falhas no sistema.

Atualizado em 28/09/2010.

Lazarus - Aplicação WinCE usando tabelas DBF

2010-08-18T16:03:00.006-03:00

Lazarus - Aplicação WinCE usando tabelas DBF

Há algum tempo eu escrevi um artigo aqui no blog chamado Lazarus - Criando uma aplicação para WinCE. Nesse artigo usei SQLite para WinCE. E a implementação tinha bastante código pois usava a unit sqlite3ds. Agora vou mostrar que é possível desenvolver usando tabelas Dbase, aquelas que tem a extensão DBF. Para isso vamos usar o componente TDbf da aba Data Access. A seguir os passos necessários:

1) Crie uma tabela Dbase.
2) Inicie uma nova aplicação e coloque um TDbf no DataModule. Na propriedade TableName localize a tabela que foi criada.
3) Nas propriedades FilePath e FilePathFull ele vai automaticamente definir o caminho do PC onde está a tabela. Depois vamos resolver isso.
4) Coloque um TDataSource no Data Module e faça a associação necessária com o TDbf.
5) Agora vamos ao form da interface e coloque os controles (da aba Data Controls) necessários para cada campo da tabela. Associe a propriedade DataSource de cada controle com o DataSource inserido no passo 4. Na propriedade DataField você pode digitar o nome do campo da tabela DBF ou, se a tabela estiver ativa, selecionar na caixa combinada. Lembre que neste form deve ser incluida a linha uses referente a unit do Data Module.
6) Coloque um TDBNavigator e ligue a propriedade DataSource adequadamente.
7) No evento OnShow do form digite o seguinte:

dbf1.FilePath := '';
dbf1.FilePathFull := '';
dbf1.Open;

Se você tiver mudado a propriedade Name do TDbf, substitua o dbf1 no código acima pelo nome que você escolheu.
Para compilar um projeto WinCE é necessário fazer algumas configurações em Project -> Project options. Na opção Paths abaixo de Compiler Options selecione wince em LCL Widget Type (various). Na opção Code generation escolha WinCE em Target OS (-T) e arm em Target CPU family (-P). Pronto. O compilador irá gerar um executável que executa apenas no PDA. Dessa forma para compilar use sempre CTRL + F9. Nos testes eu usei o Lazarus 0.9.29. Se você utiliza a versão 0.9.28 o caminho para essas configurações está em Project -> Compiler options.
Copie o executável e a tabela para o PDA e execute. Pronto, simples assim. Fiz testes com sucesso em um PDA com WM 5 e no emulador WM 6.