Margem de Segurança: O Conceito de Benjamin Graham que Protege seu Patrimônio

┌─────────────────────────────────────────────────────────────┐
│                 MARGEM DE SEGURANÇA                         │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  Valor Intrínseco (calculado): R$ 50,00                     │
│  ─────────────────────────────────────────                  │
│                                                             │
│  Preço de Mercado: R$ 35,00                                 │
│  ─────────────────────────────────                          │
│                                                             │
│  Margem de Segurança = (50 - 35) / 50 = 30%                 │
│                                                             │
│  ████████████████████████████░░░░░░░░░░  30% de proteção    │
│                                                             │
│  Quanto MAIOR a margem, MENOR o risco                       │
│                                                             │
└─────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────┐
│        QUANTO MAIOR O RISCO, MAIOR A MARGEM                 │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  BAIXO RISCO (15-25% margem)         ALTO RISCO (40%+)      │
│  ────────────────────────           ──────────────────      │
│  ✓ Lucros estáveis                  ✗ Lucros voláteis       │
│  ✓ Baixo endividamento              ✗ Alto endividamento    │
│  ✓ Setor defensivo                  ✗ Setor cíclico         │
│  ✓ Histórico longo                  ✗ Empresa nova          │
│  ✓ Dividend payer                   ✗ Não paga dividendos   │
│  ✓ Governança forte                 ✗ Governança fraca      │
│                                                             │
└─────────────────────────────────────────────────────────────┘

def calcular_margem_seguranca(valor_intrinseco, preco_mercado):
    """
    Calcula a margem de segurança de uma ação.
    
    Retorna:
    - Positivo: Ação está com desconto (oportunidade)
    - Negativo: Ação está cara (evitar)
    """
    margem = (valor_intrinseco - preco_mercado) / valor_intrinseco * 100
    return margem

valor_justo = 50.00
preco_atual = 35.00
margem = calcular_margem_seguranca(valor_justo, preco_atual)
print(f"Margem de Segurança: {margem:.1f}%")  # 30.0%

import requests

def analisar_margem_seguranca(ticker, taxa_desconto=0.12):
    """
    Analisa a margem de segurança de uma ação usando múltiplos métodos.
    """
    
    # Buscar dados fundamentalistas
    response = requests.get(
        f"https://brapi.dev/api/quote/{ticker}?fundamental=true",
        headers={"Authorization": "Bearer SEU_TOKEN"}
    )
    acao = response.json()["results"][0]
    
    preco_atual = acao["regularMarketPrice"]
    
    # Método 1: Graham Number
    eps = acao.get("earningsPerShare", 0)
    vpa = acao.get("bookValuePerShare", 0)
    graham_number = (22.5 * eps * vpa) ** 0.5 if eps > 0 and vpa > 0 else None
    
    # Método 2: Dividend Discount (Bazin)
    dividendo_anual = preco_atual * acao.get("dividendYield", 0)
    preco_teto_bazin = dividendo_anual / 0.06 if dividendo_anual > 0 else None
    
    # Método 3: P/L Histórico
    pl_atual = acao.get("priceEarnings", 0)
    pl_justo = 10  # P/L considerado justo
    preco_justo_pl = eps * pl_justo if eps > 0 else None
    
    # Calcular margens
    resultados = {
        "ticker": ticker,
        "preco_atual": preco_atual,
        "metodos": []
    }
    
    if graham_number:
        margem_graham = calcular_margem_seguranca(graham_number, preco_atual)
        resultados["metodos"].append({
            "nome": "Graham Number",
            "valor_justo": graham_number,
            "margem": margem_graham
        })
    
    if preco_teto_bazin:
        margem_bazin = calcular_margem_seguranca(preco_teto_bazin, preco_atual)
        resultados["metodos"].append({
            "nome": "Bazin (6% DY)",
            "valor_justo": preco_teto_bazin,
            "margem": margem_bazin
        })
    
    if preco_justo_pl:
        margem_pl = calcular_margem_seguranca(preco_justo_pl, preco_atual)
        resultados["metodos"].append({
            "nome": "P/L Justo (10x)",
            "valor_justo": preco_justo_pl,
            "margem": margem_pl
        })
    
    return resultados

# Exemplo de uso
resultado = analisar_margem_seguranca("ITUB4")
print(f"\n{resultado['ticker']} - Preço Atual: R$ {resultado['preco_atual']:.2f}")
for metodo in resultado["metodos"]:
    status = "✅" if metodo["margem"] > 20 else "⚠️" if metodo["margem"] > 0 else "❌"
    print(f"{status} {metodo['nome']}: R$ {metodo['valor_justo']:.2f} (Margem: {metodo['margem']:.1f}%)")

ITUB4 - Preço Atual: R$ 32.50
✅ Graham Number: R$ 42.30 (Margem: 23.2%)
⚠️ Bazin (6% DY): R$ 35.00 (Margem: 7.1%)
❌ P/L Justo (10x): R$ 28.50 (Margem: -14.0%)

def graham_number(eps, vpa):
    """
    Calcula o Graham Number.
    Fórmula: √(22.5 × EPS × VPA)
    
    Onde:
    - 22.5 = 15 (P/L máximo) × 1.5 (P/VP máximo)
    - EPS = Lucro por ação
    - VPA = Valor Patrimonial por Ação
    """
    if eps <= 0 or vpa <= 0:
        return None
    return (22.5 * eps * vpa) ** 0.5

# Exemplo
eps_itub4 = 3.50  # R$/ação
vpa_itub4 = 20.00  # R$/ação
valor_graham = graham_number(eps_itub4, vpa_itub4)
print(f"Graham Number: R$ {valor_graham:.2f}")  # R$ 39.69

def graham_modificado(eps, crescimento_5anos, aaa_yield=0.045):
    """
    Fórmula de Graham para empresas de crescimento.
    Valor = EPS × (8.5 + 2g) × (4.4 / Y)
    
    Onde:
    - 8.5 = P/L base para empresa sem crescimento
    - g = crescimento esperado (5-10 anos)
    - 4.4 = taxa AAA histórica (%)
    - Y = taxa AAA atual (%)
    """
    g = crescimento_5anos * 100  # Converter para %
    valor = eps * (8.5 + 2 * g) * (0.044 / aaa_yield)
    return valor

# Exemplo para empresa de crescimento
eps_wege = 1.20
crescimento_wege = 0.15  # 15% a.a.
valor_graham_mod = graham_modificado(eps_wege, crescimento_wege)
print(f"Graham Modificado: R$ {valor_graham_mod:.2f}")  # R$ 45.47

def gordon_growth_model(dividendo_atual, taxa_crescimento, taxa_desconto):
    """
    Modelo de Gordon para ações que pagam dividendos.
    Valor = D₁ / (r - g)
    
    Onde:
    - D₁ = Dividendo esperado no próximo ano
    - r = Taxa de desconto (retorno exigido)
    - g = Taxa de crescimento dos dividendos
    """
    if taxa_desconto <= taxa_crescimento:
        return None  # Modelo não funciona
    
    d1 = dividendo_atual * (1 + taxa_crescimento)
    valor = d1 / (taxa_desconto - taxa_crescimento)
    return valor

# Exemplo
dividendo_bbas = 2.50  # R$/ação
crescimento = 0.05  # 5% a.a.
retorno_exigido = 0.12  # 12% a.a.
valor_ddm = gordon_growth_model(dividendo_bbas, crescimento, retorno_exigido)
print(f"Valor DDM: R$ {valor_ddm:.2f}")  # R$ 37.50

def valuation_por_multiplos(acao, setor_pl_medio, setor_pvp_medio):
    """
    Valuation por comparação com múltiplos do setor.
    """
    eps = acao.get("earningsPerShare", 0)
    vpa = acao.get("bookValuePerShare", 0)
    
    # Valor justo por P/L
    valor_pl = eps * setor_pl_medio
    
    # Valor justo por P/VP
    valor_pvp = vpa * setor_pvp_medio
    
    # Média dos métodos
    valor_medio = (valor_pl + valor_pvp) / 2
    
    return {
        "por_pl": valor_pl,
        "por_pvp": valor_pvp,
        "medio": valor_medio
    }

import requests

def screening_margem_seguranca(margem_minima=25):
    """
    Encontra ações com margem de segurança acima do mínimo.
    """
    
    # Lista de ações para analisar
    tickers = [
        "ITUB4", "BBDC4", "BBAS3", "WEGE3", "VALE3",
        "PETR4", "ABEV3", "RENT3", "EGIE3", "TAEE11"
    ]
    
    response = requests.get(
        f"https://brapi.dev/api/quote/{','.join(tickers)}?fundamental=true",
        headers={"Authorization": "Bearer SEU_TOKEN"}
    )
    
    oportunidades = []
    
    for acao in response.json()["results"]:
        preco = acao["regularMarketPrice"]
        eps = acao.get("earningsPerShare", 0)
        vpa = acao.get("bookValuePerShare", 0)
        
        if eps > 0 and vpa > 0:
            graham = (22.5 * eps * vpa) ** 0.5
            margem = (graham - preco) / graham * 100
            
            if margem >= margem_minima:
                oportunidades.append({
                    "ticker": acao["symbol"],
                    "preco": preco,
                    "graham": graham,
                    "margem": margem
                })
    
    # Ordenar por margem (maior primeiro)
    oportunidades.sort(key=lambda x: x["margem"], reverse=True)
    
    return oportunidades

# Executar screening
oportunidades = screening_margem_seguranca(25)

print("\n🎯 AÇÕES COM MARGEM DE SEGURANÇA > 25%\n")
print("-" * 60)
for op in oportunidades:
    print(f"{op['ticker']:8} | Preço: R$ {op['preco']:6.2f} | "
          f"Graham: R$ {op['graham']:6.2f} | Margem: {op['margem']:5.1f}%")

🎯 AÇÕES COM MARGEM DE SEGURANÇA > 25%

------------------------------------------------------------
BBAS3    | Preço: R$  28.50 | Graham: R$  42.30 | Margem: 32.6%
BBDC4    | Preço: R$  14.20 | Graham: R$  19.80 | Margem: 28.3%
ITUB4    | Preço: R$  32.00 | Graham: R$  42.50 | Margem: 24.7%

┌─────────────────────────────────────────────────────────────┐
│                   VALUE TRAP                                │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  ❌ APARECE barata, mas tem problema estrutural             │
│                                                             │
│  Sinais de alerta:                                          │
│  ├─ Lucros em queda consistente (3+ anos)                   │
│  ├─ Perda de market share                                   │
│  ├─ Tecnologia obsoleta                                     │
│  ├─ Dívida crescente                                        │
│  ├─ Setor em declínio estrutural                            │
│  └─ Governança problemática                                 │
│                                                             │
│  Exemplo: Varejistas tradicionais vs e-commerce             │
│                                                             │
└─────────────────────────────────────────────────────────────┘

def verificar_value_trap(ticker):
    """
    Verifica sinais de value trap.
    """
    response = requests.get(
        f"https://brapi.dev/api/quote/{ticker}?fundamental=true&modules=incomeStatementHistory",
        headers={"Authorization": "Bearer SEU_TOKEN"}
    )
    acao = response.json()["results"][0]
    
    alertas = []
    
    # Verificar ROE
    roe = acao.get("returnOnEquity", 0)
    if roe < 0.10:
        alertas.append(f"⚠️ ROE baixo: {roe*100:.1f}%")
    
    # Verificar endividamento
    divida_pl = acao.get("debtToEquity", 0)
    if divida_pl > 1.5:
        alertas.append(f"⚠️ Dívida/PL alta: {divida_pl:.1f}x")
    
    # Verificar margem
    margem_liquida = acao.get("netMargin", 0)
    if margem_liquida < 0.05:
        alertas.append(f"⚠️ Margem baixa: {margem_liquida*100:.1f}%")
    
    # Verificar crescimento
    crescimento = acao.get("earningsGrowth", 0)
    if crescimento < 0:
        alertas.append(f"⚠️ Lucro em queda: {crescimento*100:.1f}%")
    
    return {
        "ticker": ticker,
        "alertas": alertas,
        "is_value_trap": len(alertas) >= 2
    }

# ❌ ERRADO: Margem de 5%
# Qualquer erro no cálculo elimina a segurança
preco_compra = valor_justo * 0.95

# ✅ CORRETO: Margem de 30%
# Proteção contra erros e imprevistos
preco_compra = valor_justo * 0.70

# Dados WEGE3 (valores ilustrativos)
dados_wege = {
    "preco_atual": 35.00,
    "eps": 1.20,
    "vpa": 6.50,
    "crescimento_5a": 0.18,  # 18% a.a.
    "roe": 0.25,             # 25%
    "divida_pl": 0.20,       # 0.2x
}

# 1. Graham Number (conservador)
graham = (22.5 * 1.20 * 6.50) ** 0.5  # R$ 13.22
margem_graham = (graham - 35) / graham * 100  # -165% (muito cara por Graham)

# 2. Graham Modificado (para crescimento)
graham_mod = 1.20 * (8.5 + 2 * 18) * (0.044 / 0.045)  # R$ 52.27
margem_mod = (52.27 - 35) / 52.27 * 100  # 33% (ok!)

# Conclusão: WEGE3 é cara por métodos value tradicionais,
# mas pode ter margem considerando o crescimento

# Dados BBAS3 (valores ilustrativos)
dados_bbas = {
    "preco_atual": 28.00,
    "eps": 5.50,
    "vpa": 32.00,
    "dividendo": 2.80,
    "roe": 0.18,
    "divida_pl": "N/A",  # Bancos não usam esta métrica
}

# 1. Graham Number
graham = (22.5 * 5.50 * 32.00) ** 0.5  # R$ 62.93
margem_graham = (62.93 - 28) / 62.93 * 100  # 55.5% (excelente!)

# 2. Bazin (6% DY)
preco_teto_bazin = 2.80 / 0.06  # R$ 46.67
margem_bazin = (46.67 - 28) / 46.67 * 100  # 40% (muito bom!)

# 3. P/L Justo (8x para bancos)
preco_pl = 5.50 * 8  # R$ 44.00
margem_pl = (44 - 28) / 44 * 100  # 36.4% (bom!)

# Conclusão: BBAS3 apresenta margem de segurança por todos os métodos
# Risco: Interferência política (justifica desconto adicional)

┌─────────────────────────────────────────────────────────────┐
│         CHECKLIST MARGEM DE SEGURANÇA                       │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  VALUATION                                                  │
│  ☐ Calcular valor por pelo menos 2 métodos                  │
│  ☐ Usar dados normalizados (média 3-5 anos)                 │
│  ☐ Ser conservador nas projeções de crescimento             │
│  ☐ Comparar com múltiplos do setor                          │
│                                                             │
│  MARGEM ADEQUADA                                            │
│  ☐ Blue chips: mínimo 20%                                   │
│  ☐ Mid caps: mínimo 30%                                     │
│  ☐ Small caps: mínimo 40%                                   │
│  ☐ Empresas problemáticas: mínimo 50%                       │
│                                                             │
│  QUALIDADE (evitar value traps)                             │
│  ☐ ROE > 12% (consistente)                                  │
│  ☐ Dívida/PL < 1.5 (ou índice adequado do setor)            │
│  ☐ Margem líquida estável ou crescente                      │
│  ☐ Lucro crescente ou estável (5 anos)                      │
│  ☐ Sem red flags de governança                              │
│                                                             │
│  CONFIRMAÇÃO                                                │
│  ☐ Entendo o negócio?                                       │
│  ☐ A margem compensa os riscos?                             │
│  ☐ Estou confortável para segurar 5+ anos?                  │
│                                                             │
└─────────────────────────────────────────────────────────────┘

import requests
from datetime import datetime

class MonitorMargemSeguranca:
    def __init__(self, token):
        self.token = token
        self.base_url = "https://brapi.dev/api"
    
    def get_dados(self, ticker):
        response = requests.get(
            f"{self.base_url}/quote/{ticker}?fundamental=true",
            headers={"Authorization": f"Bearer {self.token}"}
        )
        return response.json()["results"][0]
    
    def calcular_graham(self, acao):
        eps = acao.get("earningsPerShare", 0)
        vpa = acao.get("bookValuePerShare", 0)
        if eps > 0 and vpa > 0:
            return (22.5 * eps * vpa) ** 0.5
        return None
    
    def calcular_bazin(self, acao, dy_alvo=0.06):
        preco = acao["regularMarketPrice"]
        dy = acao.get("dividendYield", 0)
        if dy > 0:
            dividendo = preco * dy
            return dividendo / dy_alvo
        return None
    
    def analisar_carteira(self, tickers):
        resultados = []
        
        for ticker in tickers:
            acao = self.get_dados(ticker)
            preco = acao["regularMarketPrice"]
            
            graham = self.calcular_graham(acao)
            bazin = self.calcular_bazin(acao)
            
            resultado = {
                "ticker": ticker,
                "preco": preco,
                "graham": graham,
                "bazin": bazin,
                "margem_graham": ((graham - preco) / graham * 100) if graham else None,
                "margem_bazin": ((bazin - preco) / bazin * 100) if bazin else None,
            }
            resultados.append(resultado)
        
        return resultados
    
    def relatorio(self, tickers):
        resultados = self.analisar_carteira(tickers)
        
        print(f"\n📊 RELATÓRIO DE MARGEM DE SEGURANÇA")
        print(f"📅 Data: {datetime.now().strftime('%d/%m/%Y %H:%M')}")
        print("=" * 70)
        
        for r in resultados:
            print(f"\n{r['ticker']}")
            print(f"  Preço Atual: R$ {r['preco']:.2f}")
            
            if r['graham']:
                status = "✅" if r['margem_graham'] > 25 else "⚠️" if r['margem_graham'] > 0 else "❌"
                print(f"  {status} Graham: R$ {r['graham']:.2f} (Margem: {r['margem_graham']:.1f}%)")
            
            if r['bazin']:
                status = "✅" if r['margem_bazin'] > 25 else "⚠️" if r['margem_bazin'] > 0 else "❌"
                print(f"  {status} Bazin:  R$ {r['bazin']:.2f} (Margem: {r['margem_bazin']:.1f}%)")

# Uso
monitor = MonitorMargemSeguranca("SEU_TOKEN")
monitor.relatorio(["ITUB4", "BBAS3", "WEGE3", "VALE3", "EGIE3"])