Calculadora FIRE: Independência Financeira - Quanto Preciso para Aposentar?

Patrimônio Necessário = Gastos Anuais × 25

def calcular_patrimonio_fire(
    gastos_mensais: float,
    taxa_retirada: float = 4.0,
    margem_seguranca: float = 10.0
) -> dict:
    """
    Calcula patrimônio necessário para independência financeira
    
    Args:
        gastos_mensais: Gastos mensais estimados na aposentadoria
        taxa_retirada: Taxa de retirada anual (padrão 4%)
        margem_seguranca: Margem adicional (padrão 10%)
    """
    gastos_anuais = gastos_mensais * 12
    
    # Patrimônio base
    patrimonio_base = gastos_anuais / (taxa_retirada / 100)
    
    # Com margem de segurança
    patrimonio_seguro = patrimonio_base * (1 + margem_seguranca / 100)
    
    # Renda mensal que o patrimônio gera
    renda_mensal = patrimonio_base * (taxa_retirada / 100) / 12
    
    return {
        "gastos_mensais": gastos_mensais,
        "gastos_anuais": gastos_anuais,
        "taxa_retirada": taxa_retirada,
        "patrimonio_necessario": patrimonio_base,
        "patrimonio_com_margem": patrimonio_seguro,
        "renda_mensal_gerada": renda_mensal,
        "multiplicador": 100 / taxa_retirada
    }

resultado = calcular_patrimonio_fire(10000, taxa_retirada=4.0)

print("=" * 50)
print("CALCULADORA FIRE - PATRIMÔNIO NECESSÁRIO")
print("=" * 50)
print(f"Gastos mensais desejados: R$ {resultado['gastos_mensais']:,.2f}")
print(f"Gastos anuais: R$ {resultado['gastos_anuais']:,.2f}")
print(f"Taxa de retirada: {resultado['taxa_retirada']}%")
print(f"Multiplicador: {resultado['multiplicador']:.0f}x")
print(f"\nPatrimônio necessário: R$ {resultado['patrimonio_necessario']:,.2f}")
print(f"Com margem de 10%: R$ {resultado['patrimonio_com_margem']:,.2f}")

def calcular_tempo_fire(
    patrimonio_atual: float,
    aporte_mensal: float,
    meta_patrimonio: float,
    retorno_anual: float = 10.0
) -> dict:
    """
    Calcula tempo necessário para atingir o patrimônio FIRE
    """
    taxa_mensal = (1 + retorno_anual / 100) ** (1/12) - 1
    
    patrimonio = patrimonio_atual
    meses = 0
    historico = []
    
    while patrimonio < meta_patrimonio and meses < 600:  # máximo 50 anos
        patrimonio = patrimonio * (1 + taxa_mensal) + aporte_mensal
        meses += 1
        
        if meses % 12 == 0:
            historico.append({
                "ano": meses // 12,
                "patrimonio": patrimonio
            })
    
    anos = meses / 12
    total_aportado = patrimonio_atual + (aporte_mensal * meses)
    rendimentos = patrimonio - total_aportado
    
    return {
        "patrimonio_inicial": patrimonio_atual,
        "aporte_mensal": aporte_mensal,
        "meta": meta_patrimonio,
        "retorno_anual": retorno_anual,
        "meses": meses,
        "anos": anos,
        "patrimonio_final": patrimonio,
        "total_aportado": total_aportado,
        "rendimentos": rendimentos,
        "historico": historico
    }

# Exemplo: começando com R$ 50.000, aportando R$ 3.000/mês
meta = 3_000_000  # R$ 3 milhões
resultado = calcular_tempo_fire(50000, 3000, meta, retorno_anual=10)

print("=" * 50)
print("CALCULADORA FIRE - TEMPO PARA META")
print("=" * 50)
print(f"Patrimônio inicial: R$ {resultado['patrimonio_inicial']:,.2f}")
print(f"Aporte mensal: R$ {resultado['aporte_mensal']:,.2f}")
print(f"Meta: R$ {resultado['meta']:,.2f}")
print(f"Retorno anual esperado: {resultado['retorno_anual']}%")
print(f"\nTempo necessário: {resultado['anos']:.1f} anos ({resultado['meses']} meses)")
print(f"Total aportado: R$ {resultado['total_aportado']:,.2f}")
print(f"Rendimentos: R$ {resultado['rendimentos']:,.2f}")

print("\nEVOLUÇÃO ANUAL:")
for ano in resultado['historico'][:10]:
    print(f"  Ano {ano['ano']:2}: R$ {ano['patrimonio']:>15,.2f}")

def calcular_idade_fire(
    idade_atual: int,
    renda_mensal: float,
    gastos_mensais: float,
    patrimonio_atual: float = 0,
    retorno_anual: float = 10.0,
    taxa_retirada: float = 4.0
) -> dict:
    """
    Calcula em qual idade você atinge FIRE baseado na taxa de poupança
    """
    # Taxa de poupança
    poupanca_mensal = renda_mensal - gastos_mensais
    taxa_poupanca = (poupanca_mensal / renda_mensal) * 100
    
    # Meta de patrimônio
    gastos_anuais = gastos_mensais * 12
    meta = gastos_anuais / (taxa_retirada / 100)
    
    # Simulação
    taxa_mensal = (1 + retorno_anual / 100) ** (1/12) - 1
    patrimonio = patrimonio_atual
    meses = 0
    
    while patrimonio < meta and meses < 600:
        patrimonio = patrimonio * (1 + taxa_mensal) + poupanca_mensal
        meses += 1
    
    idade_fire = idade_atual + (meses / 12)
    
    return {
        "idade_atual": idade_atual,
        "renda_mensal": renda_mensal,
        "gastos_mensais": gastos_mensais,
        "poupanca_mensal": poupanca_mensal,
        "taxa_poupanca": taxa_poupanca,
        "meta_patrimonio": meta,
        "meses_restantes": meses,
        "anos_restantes": meses / 12,
        "idade_fire": idade_fire
    }

# Exemplo: 30 anos, R$ 12.000 de renda, R$ 7.000 de gastos
resultado = calcular_idade_fire(
    idade_atual=30,
    renda_mensal=12000,
    gastos_mensais=7000,
    patrimonio_atual=100000
)

print("=" * 50)
print("CALCULADORA FIRE - IDADE DE APOSENTADORIA")
print("=" * 50)
print(f"Idade atual: {resultado['idade_atual']} anos")
print(f"Renda mensal: R$ {resultado['renda_mensal']:,.2f}")
print(f"Gastos mensais: R$ {resultado['gastos_mensais']:,.2f}")
print(f"Poupança mensal: R$ {resultado['poupanca_mensal']:,.2f}")
print(f"Taxa de poupança: {resultado['taxa_poupanca']:.1f}%")
print(f"\nMeta de patrimônio: R$ {resultado['meta_patrimonio']:,.2f}")
print(f"Anos para FIRE: {resultado['anos_restantes']:.1f}")
print(f"Idade FIRE: {resultado['idade_fire']:.0f} anos")

def simulacao_fire_completa(
    idade_atual: int,
    patrimonio_atual: float,
    aporte_mensal: float,
    gastos_aposentadoria: float,
    taxa_retirada: float = 4.0
) -> dict:
    """
    Simula diferentes cenários de FIRE
    """
    meta = (gastos_aposentadoria * 12) / (taxa_retirada / 100)
    
    cenarios = {
        "conservador": {"retorno": 6, "nome": "Conservador (6% a.a.)"},
        "moderado": {"retorno": 8, "nome": "Moderado (8% a.a.)"},
        "agressivo": {"retorno": 10, "nome": "Agressivo (10% a.a.)"},
        "otimista": {"retorno": 12, "nome": "Otimista (12% a.a.)"},
    }
    
    resultados = {}
    
    for key, cenario in cenarios.items():
        retorno = cenario["retorno"]
        taxa_mensal = (1 + retorno / 100) ** (1/12) - 1
        
        patrimonio = patrimonio_atual
        meses = 0
        
        while patrimonio < meta and meses < 600:
            patrimonio = patrimonio * (1 + taxa_mensal) + aporte_mensal
            meses += 1
        
        resultados[key] = {
            "nome": cenario["nome"],
            "retorno": retorno,
            "meses": meses,
            "anos": meses / 12,
            "idade_fire": idade_atual + (meses / 12),
            "patrimonio_final": patrimonio
        }
    
    return {
        "meta": meta,
        "cenarios": resultados
    }

# Simulação completa
resultado = simulacao_fire_completa(
    idade_atual=28,
    patrimonio_atual=80000,
    aporte_mensal=4000,
    gastos_aposentadoria=8000
)

print("=" * 60)
print("SIMULAÇÃO FIRE - MÚLTIPLOS CENÁRIOS")
print("=" * 60)
print(f"Meta de patrimônio: R$ {resultado['meta']:,.2f}")
print(f"\n{'Cenário':<25} {'Anos':<10} {'Idade FIRE':<12}")
print("-" * 50)

for key, cenario in resultado['cenarios'].items():
    print(f"{cenario['nome']:<25} {cenario['anos']:<10.1f} {cenario['idade_fire']:<12.0f}")

def simular_retirada_fixa(
    patrimonio_inicial: float,
    taxa_retirada: float,
    anos_simulacao: int,
    retorno_anual: float,
    inflacao: float
) -> list:
    """
    Simula retirada fixa ajustada pela inflação
    """
    patrimonio = patrimonio_inicial
    retirada_inicial = patrimonio * (taxa_retirada / 100)
    retirada_atual = retirada_inicial
    
    historico = []
    
    for ano in range(1, anos_simulacao + 1):
        # Rendimento
        rendimento = patrimonio * (retorno_anual / 100)
        
        # Retirada ajustada pela inflação
        retirada_atual *= (1 + inflacao / 100)
        
        # Novo patrimônio
        patrimonio = patrimonio + rendimento - retirada_atual
        
        historico.append({
            "ano": ano,
            "patrimonio": patrimonio,
            "retirada_anual": retirada_atual,
            "retirada_mensal": retirada_atual / 12
        })
        
        if patrimonio <= 0:
            break
    
    return historico

# Simular 30 anos de aposentadoria
historico = simular_retirada_fixa(
    patrimonio_inicial=3_000_000,
    taxa_retirada=4,
    anos_simulacao=30,
    retorno_anual=8,
    inflacao=4
)

print("SIMULAÇÃO DE RETIRADA FIXA (30 anos)")
print("=" * 60)
print(f"{'Ano':<6} {'Patrimônio':<18} {'Retirada Anual':<18} {'Mensal':<15}")
print("-" * 60)

for ano in historico[::5]:  # A cada 5 anos
    print(f"{ano['ano']:<6} R$ {ano['patrimonio']:>12,.0f}   "
          f"R$ {ano['retirada_anual']:>12,.0f}   R$ {ano['retirada_mensal']:>10,.0f}")

if historico[-1]['patrimonio'] > 0:
    print(f"\nPatrimônio final após 30 anos: R$ {historico[-1]['patrimonio']:,.2f}")
else:
    print(f"\nDinheiro acabou no ano {len(historico)}")

import requests
from datetime import datetime

def dashboard_fire(
    patrimonio_investido: dict,
    meta_fire: float,
    gastos_mensais: float,
    token: str
) -> None:
    """
    Dashboard de acompanhamento do progresso FIRE
    
    patrimonio_investido: {"BOVA11": 1000, "IVVB11": 500, ...}
    """
    # Buscar cotações
    tickers = list(patrimonio_investido.keys())
    url = f"https://brapi.dev/api/quote/{','.join(tickers)}"
    headers = {"Authorization": f"Bearer {token}"}
    
    response = requests.get(url, headers=headers)
    data = response.json()
    
    # Calcular patrimônio atual
    patrimonio_total = 0
    detalhes = []
    
    for resultado in data["results"]:
        ticker = resultado["symbol"]
        preco = resultado["regularMarketPrice"]
        quantidade = patrimonio_investido[ticker]
        valor = preco * quantidade
        patrimonio_total += valor
        
        detalhes.append({
            "ticker": ticker,
            "quantidade": quantidade,
            "preco": preco,
            "valor": valor
        })
    
    # Calcular progresso
    progresso = (patrimonio_total / meta_fire) * 100
    faltando = meta_fire - patrimonio_total
    
    # Renda que o patrimônio atual gera (4%)
    renda_atual_anual = patrimonio_total * 0.04
    renda_atual_mensal = renda_atual_anual / 12
    cobertura = (renda_atual_mensal / gastos_mensais) * 100
    
    print("\n" + "=" * 60)
    print(f"DASHBOARD FIRE - {datetime.now().strftime('%d/%m/%Y')}")
    print("=" * 60)
    
    print(f"\nPATRIMÔNIO ATUAL:")
    for d in detalhes:
        print(f"  {d['ticker']}: {d['quantidade']} cotas × R$ {d['preco']:.2f} = R$ {d['valor']:,.2f}")
    
    print(f"\nRESUMO:")
    print(f"  Patrimônio total: R$ {patrimonio_total:,.2f}")
    print(f"  Meta FIRE: R$ {meta_fire:,.2f}")
    print(f"  Faltando: R$ {faltando:,.2f}")
    
    # Barra de progresso
    barra_cheia = int(progresso / 5)
    barra = "█" * barra_cheia + "░" * (20 - barra_cheia)
    print(f"\n  Progresso: [{barra}] {progresso:.1f}%")
    
    print(f"\nRENDA PASSIVA (taxa 4%):")
    print(f"  Renda mensal atual: R$ {renda_atual_mensal:,.2f}")
    print(f"  Gastos mensais: R$ {gastos_mensais:,.2f}")
    print(f"  Cobertura: {cobertura:.1f}%")

# Exemplo de uso
meu_patrimonio = {
    "BOVA11": 500,
    "IVVB11": 300,
    "XPLG11": 200,
    "KNRI11": 150,
}

dashboard_fire(
    patrimonio_investido=meu_patrimonio,
    meta_fire=2_500_000,
    gastos_mensais=8000,
    token="SEU_TOKEN"
)

import requests

def calcular_aporte_necessario(
    patrimonio_atual: float,
    meta_fire: float,
    anos_para_fire: int,
    retorno_anual: float = 10.0
) -> dict:
    """
    Calcula o aporte mensal necessário para atingir FIRE em X anos
    """
    taxa_mensal = (1 + retorno_anual / 100) ** (1/12) - 1
    meses = anos_para_fire * 12
    
    # Valor futuro do patrimônio atual
    vf_atual = patrimonio_atual * ((1 + taxa_mensal) ** meses)
    
    # Quanto falta acumular
    falta = meta_fire - vf_atual
    
    # Aporte mensal necessário (fórmula PMT)
    if taxa_mensal > 0 and falta > 0:
        fator = ((1 + taxa_mensal) ** meses - 1) / taxa_mensal
        aporte_mensal = falta / fator
    else:
        aporte_mensal = 0
    
    return {
        "patrimonio_atual": patrimonio_atual,
        "meta_fire": meta_fire,
        "anos": anos_para_fire,
        "retorno_anual": retorno_anual,
        "vf_patrimonio_atual": vf_atual,
        "falta_acumular": falta,
        "aporte_mensal": max(0, aporte_mensal),
        "aporte_anual": max(0, aporte_mensal * 12)
    }

# Exemplo: Quero FIRE em 15 anos
resultado = calcular_aporte_necessario(
    patrimonio_atual=150000,
    meta_fire=3000000,
    anos_para_fire=15,
    retorno_anual=10
)

print("APORTE NECESSÁRIO PARA FIRE")
print("=" * 50)
print(f"Patrimônio atual: R$ {resultado['patrimonio_atual']:,.2f}")
print(f"Meta FIRE: R$ {resultado['meta_fire']:,.2f}")
print(f"Prazo: {resultado['anos']} anos")
print(f"Retorno esperado: {resultado['retorno_anual']}% a.a.")
print(f"\nPatrimônio atual valerá: R$ {resultado['vf_patrimonio_atual']:,.2f}")
print(f"Falta acumular: R$ {resultado['falta_acumular']:,.2f}")
print(f"\nAporte mensal necessário: R$ {resultado['aporte_mensal']:,.2f}")
print(f"Aporte anual: R$ {resultado['aporte_anual']:,.2f}")

def carteira_fire_brasil(valor_total: float) -> dict:
    """
    Exemplo de carteira FIRE para o Brasil
    """
    # Alocação sugerida
    alocacao = {
        # Renda Fixa (40%)
        "Tesouro IPCA+ 2045": 0.15,
        "CDBs/LCIs/LCAs": 0.15,
        "Debêntures incentivadas": 0.10,
        
        # Renda Variável Brasil (35%)
        "ETFs (BOVA11, DIVO11)": 0.15,
        "FIIs": 0.12,
        "Ações dividendos": 0.08,
        
        # Internacional (20%)
        "ETFs EUA (IVVB11)": 0.15,
        "ETFs Global": 0.05,
        
        # Reserva (5%)
        "Tesouro Selic / CDB liquidez": 0.05,
    }
    
    carteira = []
    for ativo, peso in alocacao.items():
        valor = valor_total * peso
        carteira.append({
            "ativo": ativo,
            "peso": peso,
            "valor": valor
        })
    
    return carteira

# Carteira FIRE de R$ 2 milhões
carteira = carteira_fire_brasil(2_000_000)

print("CARTEIRA FIRE BRASIL")
print("=" * 50)
for ativo in carteira:
    print(f"{ativo['ativo']:<30} {ativo['peso']*100:>5.0f}%  R$ {ativo['valor']:>12,.0f}")