Avaliação de Empresas Jovens com Python

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

class StartupValuation:
    """
    Classe para avaliação de startups utilizando métodos de FCD
    com ajustes específicos para empresas jovens.
    """
    
    def __init__(self, company_name):
        self.company_name = company_name
        self.projections = None
        self.wacc = None
        self.terminal_growth_rate = None
        self.failure_probability = None
        self.liquidation_value = None
        
    def set_wacc(self, wacc):
        """Define o WACC (Weighted Average Cost of Capital)"""
        self.wacc = wacc
    
    def set_terminal_growth_rate(self, growth_rate):
        """Define a taxa de crescimento perpétuo"""
        self.terminal_growth_rate = growth_rate
    
    def set_failure_probability(self, probability, liquidation_value=0):
        """Define a probabilidade de falha da startup e o valor de liquidação"""
        self.failure_probability = probability
        self.liquidation_value = liquidation_value

def create_projection(self, years, initial_revenue=None, revenue_growth=None, 
                     ebitda_margin=None, tax_rate=None, capex_percent=None, 
                     nwc_percent=None, depreciation_percent=None):
    """
    Cria projeções financeiras para a startup
    
    Args:
        years: Número de anos para projeção
        initial_revenue: Receita inicial
        revenue_growth: Lista ou array com taxas de crescimento da receita
        ebitda_margin: Lista ou array com margens EBITDA
        tax_rate: Taxa de imposto efetiva
        capex_percent: CAPEX como % da receita
        nwc_percent: Variação do capital de giro como % da variação da receita
        depreciation_percent: Depreciação como % da receita
    """
    periods = list(range(years + 1))  # Inclui ano 0
    
    # Criar DataFrame para projeções
    self.projections = pd.DataFrame(index=periods)
    self.projections.index.name = 'Ano'
    
    # Projetar Receita
    self.projections['Receita'] = 0
    if initial_revenue is not None and revenue_growth is not None:
        self.projections.loc[0, 'Receita'] = initial_revenue
        for year in range(1, years + 1):
            growth = revenue_growth[year-1] if isinstance(revenue_growth, (list, np.ndarray)) else revenue_growth
            self.projections.loc[year, 'Receita'] = self.projections.loc[year-1, 'Receita'] * (1 + growth)
    
    # Projetar EBITDA até FCF
    if ebitda_margin is not None:
        # Código para projetar EBITDA, EBIT, Impostos, etc.
        # ...
        
        # Calcular FCF
        self.projections['FCF'] = (self.projections['NOPAT'] + 
                                  self.projections['Depreciação'] - 
                                  self.projections['CAPEX'] - 
                                  self.projections['Var_NWC'])

def calculate_dcf_value(self):
    """Calcula o valor da empresa pelo método FCD"""
    if self.projections is None or 'FCF' not in self.projections:
        raise ValueError("Projeções não definidas ou FCF não calculado")
        
    if self.wacc is None or self.terminal_growth_rate is None:
        raise ValueError("WACC ou taxa de crescimento perpétuo não definidos")
        
    # Calcular o valor presente dos fluxos de caixa projetados
    years = len(self.projections) - 1  # Descontar o ano 0
    pv_factors = 1 / (1 + self.wacc) ** np.arange(1, years + 1)
    
    fcf_values = self.projections.loc[1:years, 'FCF'].values
    pv_fcf = np.sum(fcf_values * pv_factors)
    
    # Calcular o valor terminal e seu valor presente
    final_fcf = self.projections.loc[years, 'FCF']
    terminal_value = final_fcf * (1 + self.terminal_growth_rate) / (self.wacc - self.terminal_growth_rate)
    pv_terminal = terminal_value / (1 + self.wacc) ** years
    
    # Calcular o valor total da empresa
    enterprise_value = pv_fcf + pv_terminal
    
    # Ajustar para probabilidade de falha
    if self.failure_probability is not None:
        enterprise_value = enterprise_value * (1 - self.failure_probability) + self.liquidation_value * self.failure_probability
        
    return {
        'pv_fcf': pv_fcf,
        'terminal_value': terminal_value,
        'pv_terminal': pv_terminal, 
        'enterprise_value': enterprise_value,
        'percent_terminal': pv_terminal / enterprise_value * 100
    }

class StartupMetrics:
    """Classe para calcular e analisar métricas específicas para startups"""
    
    def calculate_cac(self, marketing_cost, sales_cost, new_customers):
        """Calcula o Custo de Aquisição de Cliente (CAC)"""
        if new_customers == 0:
            return float('inf')
        
        return (marketing_cost + sales_cost) / new_customers
    
    def calculate_ltv(self, arpu, gross_margin_percent, churn_rate_monthly, 
                     discount_rate_monthly=None, periods=None):
        """Calcula o Lifetime Value (LTV) de um cliente"""
        if churn_rate_monthly <= 0 or churn_rate_monthly >= 1:
            raise ValueError("A taxa de churn deve estar entre 0 e 1")
        
        margin = arpu * gross_margin_percent
        
        # Se uma taxa de desconto mensal for fornecida e/ou um número máximo de períodos
        if discount_rate_monthly is not None or periods is not None:
            cash_flows = []
            retention_rate = 1 - churn_rate_monthly
            remaining_customers = 1.0  # Começamos com 1 cliente
            
            # Se periods não for especificado, usar um valor suficientemente grande
            max_periods = periods if periods is not None else int(5 / churn_rate_monthly)
            
            for t in range(max_periods):
                if t > 0:
                    remaining_customers *= retention_rate
                period_cash_flow = margin * remaining_customers
                cash_flows.append(period_cash_flow)
            
            # Calcular o valor presente
            if discount_rate_monthly is None:
                # Sem desconto temporal
                return sum(cash_flows)
            else:
                discount_factors = 1 / (1 + discount_rate_monthly) ** np.arange(1, max_periods + 1)
                return sum(np.array(cash_flows) * discount_factors)
        else:
            # Fórmula simplificada para perpetuidade (sem desconto)
            return margin / churn_rate_monthly
    
    def calculate_ltv_to_cac_ratio(self, ltv, cac):
        """Calcula a razão LTV/CAC"""
        if cac <= 0:
            return float('inf')
        
        return ltv / cac

def plot_ltv_sensitivity(self, arpu, gross_margin_percent, 
                       churn_rates, discount_rates=None):
    """Analisa a sensibilidade do LTV à mudanças na taxa de churn e desconto"""
    if discount_rates is not None and len(discount_rates) > 0:
        # Análise bidimensional: churn vs desconto
        ltv_matrix = np.zeros((len(churn_rates), len(discount_rates)))
        
        for i, churn in enumerate(churn_rates):
            for j, discount in enumerate(discount_rates):
                ltv_matrix[i, j] = self.calculate_ltv(arpu, gross_margin_percent, churn, discount)
        
        plt.figure(figsize=(12, 8))
        
        # Criar heatmap
        heatmap = plt.pcolor(ltv_matrix, cmap='viridis')
        
        # Configurar eixos
        plt.colorbar(heatmap, label='LTV')
        plt.xticks(np.arange(0.5, len(discount_rates), 1), [f"{rate:.1%}" for rate in discount_rates])
        plt.yticks(np.arange(0.5, len(churn_rates), 1), [f"{rate:.1%}" for rate in churn_rates])
        
        plt.xlabel('Taxa de Desconto Mensal')
        plt.ylabel('Taxa de Churn Mensal')
        plt.title(f'Análise de Sensibilidade do LTV - ARPU: R${arpu}, Margem: {gross_margin_percent:.0%}')
    
    # ... código para retornar o plot ...

def project_customer_growth(self, initial_customers, monthly_growth_rate, 
                           churn_rate_monthly, periods):
    """Projeta o crescimento da base de clientes"""
    # Inicializar DataFrame
    projection = pd.DataFrame(index=range(periods+1))
    projection.index.name = 'Mês'
    
    # Inicializar colunas
    projection['Clientes Início'] = 0
    projection['Novos Clientes'] = 0
    projection['Churn'] = 0
    projection['Clientes Fim'] = 0
    
    # Preencher mês inicial
    projection.loc[0, 'Clientes Início'] = initial_customers
    projection.loc[0, 'Novos Clientes'] = 0
    projection.loc[0, 'Churn'] = 0
    projection.loc[0, 'Clientes Fim'] = initial_customers
    
    # Calcular projeção mês a mês
    for month in range(1, periods+1):
        # Clientes no início do mês = Clientes no fim do mês anterior
        projection.loc[month, 'Clientes Início'] = projection.loc[month-1, 'Clientes Fim']
        
        # Novos clientes adquiridos no mês
        new_customers = projection.loc[0, 'Clientes Fim'] * (1 + monthly_growth_rate) ** month - \
                       projection.loc[0, 'Clientes Fim'] * (1 + monthly_growth_rate) ** (month-1)
        projection.loc[month, 'Novos Clientes'] = new_customers
        
        # Churn no mês
        projection.loc[month, 'Churn'] = projection.loc[month, 'Clientes Início'] * churn_rate_monthly
        
        # Clientes no fim do mês
        projection.loc[month, 'Clientes Fim'] = projection.loc[month, 'Clientes Início'] + \
                                              projection.loc[month, 'Novos Clientes'] - \
                                              projection.loc[month, 'Churn']
    
    return projection

def project_mrr(self, customer_projection, arpu):
    """Projeta o MRR com base na projeção de clientes"""
    mrr_projection = customer_projection.copy()
    mrr_projection['MRR'] = mrr_projection['Clientes Fim'] * arpu
    
    return mrr_projection

class IntegratedStartupValuation:
    """Classe que integra avaliação FCD com métricas específicas de startups"""
    
    def __init__(self, company_name):
        self.metrics = StartupMetrics()
        self.valuation = StartupValuation(company_name)
    
    def project_from_unit_economics(self, 
                                   initial_customers, 
                                   monthly_growth_rate,
                                   churn_rate_monthly,
                                   arpu,
                                   gross_margin,
                                   cac,
                                   fixed_costs_monthly,
                                   tax_rate,
                                   capex_percent,
                                   nwc_percent,
                                   projection_years,
                                   wacc,
                                   terminal_growth_rate,
                                   failure_probability=None):
        """
        Projeta fluxos de caixa baseados em métricas unitárias (unit economics)
        e calcula o valor da empresa
        """
        # Projetar crescimento de clientes
        customer_projection = self.metrics.project_customer_growth(
            initial_customers, monthly_growth_rate, churn_rate_monthly, projection_years * 12
        )
        
        # Projetar MRR
        mrr_projection = self.metrics.project_mrr(customer_projection, arpu)
        
        # Agregar mensalmente para anualmente
        annual_data = {}
        for year in range(projection_years + 1):
            start_month = year * 12
            end_month = (year + 1) * 12 - 1
            
            if end_month >= len(mrr_projection):
                end_month = len(mrr_projection) - 1
                
            if start_month <= end_month:
                # Calcular receita anual (MRR médio * 12)
                annual_data[year] = {
                    'Receita': mrr_projection.loc[start_month:end_month, 'MRR'].mean() * 12,
                    'Clientes': mrr_projection.loc[end_month, 'Clientes Fim']
                }
            
        # Criar projeções financeiras
        revenue = [annual_data[year]['Receita'] for year in range(projection_years + 1)]
        
        # Calcular custos variáveis e margem EBITDA
        fixed_costs_annual = fixed_costs_monthly * 12
        ebitda_margin = []
        
        for year in range(projection_years + 1):
            if year in annual_data:
                variable_costs = annual_data[year]['Receita'] * (1 - gross_margin)
                total_costs = variable_costs + fixed_costs_annual
                ebitda = annual_data[year]['Receita'] - total_costs
                margin = ebitda / annual_data[year]['Receita'] if annual_data[year]['Receita'] > 0 else -1
                ebitda_margin.append(margin)
            else:
                ebitda_margin.append(0)
        
        # Configurar avaliação
        self.valuation.set_wacc(wacc)
        self.valuation.set_terminal_growth_rate(terminal_growth_rate)
        
        if failure_probability is not None:
            self.valuation.set_failure_probability(failure_probability)
        
        # Calcular crescimento entre anos
        revenue_growth = []
        for i in range(1, len(revenue)):
            if revenue[i-1] > 0:
                growth = (revenue[i] - revenue[i-1]) / revenue[i-1]
            else:
                growth = 1.0  # 100% growth if previous revenue was zero
            revenue_growth.append(growth)
        
        # Criar projeção
        self.valuation.create_projection(
            years=projection_years,
            initial_revenue=revenue[0],
            revenue_growth=revenue_growth,
            ebitda_margin=ebitda_margin,
            tax_rate=tax_rate,
            capex_percent=capex_percent,
            nwc_percent=nwc_percent,
            depreciation_percent=0.1  # Assumir 10% como exemplo
        )
        
        # Calcular valor
        result = self.valuation.calculate_dcf_value()
        
        # Calcular métricas adicionais
        ltv = self.metrics.calculate_ltv(arpu, gross_margin, churn_rate_monthly, wacc/12)
        ltv_cac_ratio = self.metrics.calculate_ltv_to_cac_ratio(ltv, cac)
        
        result['ltv'] = ltv
        result['cac'] = cac
        result['ltv_cac_ratio'] = ltv_cac_ratio
        
        return result