Como Automatizar Operações de Long & Short Usando Python

import pandas as pd
import numpy as np
from sklearn.linear_model import LinearRegression

def detect_cointegration_opportunity(asset1, asset2, lookback=60):
    # Calcula o spread entre os ativos
    spread = asset1 - asset2
    
    # Identifica oportunidade quando spread sai da banda
    zscore = (spread[-1] - spread[-lookback:].mean()) / spread[-lookback:].std()
    
    if zscore > 2:  # Asset1 caro, Asset2 barato
        return "short_asset1_long_asset2"
    elif zscore < -2:  # Asset1 barato, Asset2 caro
        return "long_asset1_short_asset2"
    
    return "no_signal"

# Calcular correlação rolling entre 100 pares de ações
import pandas as pd
import numpy as np

# Em Python (3 linhas)
returns = prices.pct_change()
correlations = returns.rolling(60).corr()
signals = correlations[correlations.abs() > 0.8]

# Em C++, o mesmo código teria 50+ linhas
# Em R, seria mais lento para datasets grandes
# Em JavaScript, não teria bibliotecas adequadas

# Estratégia simples de pairs trading
def pairs_strategy(bbdc4, itub4, window=30):
    ratio = bbdc4 / itub4
    mean_ratio = ratio.rolling(window).mean()
    std_ratio = ratio.rolling(window).std()
    
    zscore = (ratio - mean_ratio) / std_ratio
    
    signals = pd.Series(index=ratio.index, dtype=float)
    signals[zscore > 2] = -1  # Short BBDC4, Long ITUB4
    signals[zscore < -2] = 1   # Long BBDC4, Short ITUB4
    signals[abs(zscore) < 0.5] = 0  # Close positions
    
    return signals

def stat_arb_signals(asset1, asset2, lookback=60):
    # Calcula spread normalizado
    spread = (asset1 - asset2) / asset2
    
    # Identifica extremos estatísticos
    upper_band = spread.rolling(lookback).mean() + 2 * spread.rolling(lookback).std()
    lower_band = spread.rolling(lookback).mean() - 2 * spread.rolling(lookback).std()
    
    # Gera sinais
    long_signal = spread < lower_band
    short_signal = spread > upper_band
    
    return long_signal, short_signal

def analyze_correlation_stability(asset1, asset2, periods=[30, 60, 90, 120]):
    correlations = {}
    
    for period in periods:
        corr = asset1.rolling(period).corr(asset2.rolling(period))
        correlations[f'{period}d'] = {
            'mean': corr.mean(),
            'std': corr.std(),
            'min': corr.min(),
            'stability_score': corr.mean() / corr.std()  # Maior é melhor
        }
    
    return correlations

from statsmodels.tsa.stattools import coint

def test_cointegration(asset1, asset2):
    score, pvalue, _ = coint(asset1, asset2)
    
    if pvalue < 0.05:
        return "Cointegrated - GOOD PAIR"
    elif pvalue < 0.10:
        return "Weakly Cointegrated - MODERATE PAIR"
    else:
        return "Not Cointegrated - AVOID"

def rank_pairs_by_profitability(universe, lookback=252):
    results = []
    
    for i, asset1 in enumerate(universe):
        for asset2 in universe[i+1:]:
            # Calcula métricas de qualidade do par
            correlation = asset1.corr(asset2)
            _, pvalue, _ = coint(asset1, asset2)
            volatility_ratio = asset1.std() / asset2.std()
            
            # Score composto (0-100)
            pair_score = (
                correlation * 40 +  # 40% peso na correlação
                (1 - pvalue) * 30 +  # 30% peso na cointegração  
                (1 / abs(volatility_ratio - 1) if volatility_ratio != 1 else 0) * 20 +  # 20% volatilidade similar
                (min(asset1.volume, asset2.volume) / 1e6) * 10  # 10% liquidez
            )
            
            results.append({
                'pair': f'{asset1.name}_{asset2.name}',
                'score': pair_score,
                'correlation': correlation,
                'cointegration_pvalue': pvalue
            })
    
    return sorted(results, key=lambda x: x['score'], reverse=True)

# Exemplo de gestão para capital pequeno
def position_sizing_small_account(capital=10000, pairs=3, risk_per_trade=0.02):
    max_risk_per_pair = capital * risk_per_trade / pairs
    position_size = max_risk_per_pair / 0.05  # Assumindo 5% de stop
    
    print(f"Capital total: R$ {capital:,.2f}")
    print(f"Risco máximo por par: R$ {max_risk_per_pair:,.2f}") 
    print(f"Tamanho ideal da posição: R$ {position_size:,.2f}")
    
    return position_size

# Resultado: Posições de ~R$ 1.333 por lado

def calculate_minimum_viable_capital(expected_annual_return=0.25, fixed_costs_monthly=800):
    annual_fixed_costs = fixed_costs_monthly * 12
    
    # Capital mínimo para que custos fixos sejam <= 10% do lucro esperado
    min_capital = (annual_fixed_costs / 0.10) / expected_annual_return
    
    return min_capital

# Com 25% de retorno anual e R$ 800/mês de custos:
# Capital mínimo = R$ 38.400

import yfinance as yf

# Dados históricos completos sem custo
data = yf.download(['PETR4.SA', 'VALE3.SA'], 
                   start='2020-01-01', 
                   end='2024-01-01')

# Qualidade: 95% de accuracy para backtesting
# Limitação: Dados com 15-20min de delay

import backtrader as bt

class PairsStrategy(bt.Strategy):
    def __init__(self):
        self.spread = self.data0 - self.data1
        self.zscore = bt.ind.ZScore(self.spread, period=60)
    
    def next(self):
        if self.zscore > 2 and not self.position:
            self.sell(data=self.data0, size=100)  # Short overvalued
            self.buy(data=self.data1, size=100)   # Long undervalued

import MetaTrader5 as mt5

# Conexão direta com broker
if mt5.initialize():
    # Execução de ordens em <100ms
    request = {
        "action": mt5.TRADE_ACTION_DEAL,
        "symbol": "PETR4",
        "volume": 100,
        "type": mt5.ORDER_TYPE_BUY,
        "deviation": 20,
    }
    result = mt5.order_send(request)

import requests

def send_trade_alert(message):
    bot_token = "YOUR_BOT_TOKEN"
    chat_id = "YOUR_CHAT_ID"
    url = f"https://api.telegram.org/bot{bot_token}/sendMessage"
    
    requests.post(url, data={
        'chat_id': chat_id,
        'text': message
    })

# Receba alertas instantâneos no celular
send_trade_alert("🚀 PETR4/VALE3 - Entry signal detected! Spread: -2.1σ")

# ERRADO - Usa informação que não estava disponível
def bad_strategy(prices):
    future_max = prices.rolling(20).max().shift(-20)  # Espia o futuro!
    signals = prices < future_max * 0.95
    return signals

# CORRETO - Apenas informações do passado
def good_strategy(prices):
    sma_20 = prices.rolling(20).mean()
    signals = prices < sma_20 * 0.95  # Só usa dados até o momento atual
    return signals

def robust_backtest_universe():
    # Inclui ações que foram delisted, sofreram splits, etc
    universe = [
        'PETR4.SA', 'VALE3.SA',  # Sobreviventes
        'MMXM3.SA',  # Faliu em 2012 - deve estar no teste!
        'OGXP3.SA',  # Faliu em 2013 - deve estar no teste!
        # ... incluir todos os ativos do período
    ]
    return universe

# ERRADO - Overfitting clássico
def overfit_strategy():
    best_profit = 0
    best_params = {}
    
    # Testa todas as combinações possíveis
    for ma_short in range(5, 50):
        for ma_long in range(50, 200):
            for threshold in np.arange(0.01, 0.10, 0.001):
                profit = backtest(ma_short, ma_long, threshold)
                if profit > best_profit:
                    best_profit = profit
                    best_params = {'ma_short': ma_short, 'ma_long': ma_long, 'threshold': threshold}
    
    return best_params  # Praticamente inútil para o futuro!

# CORRETO - Validação robusta
def robust_parameter_selection():
    # 1. Split temporal dos dados
    train_data = data['2015':'2020']
    validation_data = data['2021':'2022']
    test_data = data['2023':'2024']
    
    # 2. Otimiza apenas no período de treino
    best_params = optimize_on_train_data(train_data)
    
    # 3. Valida no período intermediário
    validation_profit = backtest(validation_data, **best_params)
    
    # 4. Se validação é boa, teste final
    if validation_profit > minimum_threshold:
        final_result = backtest(test_data, **best_params)
        return final_result
    
    return "Strategy failed validation"

import pandas as pd
import numpy as np
from dataclasses import dataclass
from typing import Dict, List, Tuple

@dataclass
class BacktestResult:
    total_return: float
    sharpe_ratio: float
    max_drawdown: float
    win_rate: float
    avg_trade_duration: float
    total_trades: int

class ProfessionalBacktester:
    def __init__(self, initial_capital=100000, commission=0.001):
        self.initial_capital = initial_capital
        self.commission = commission
        
    def run_pairs_backtest(self, asset1: pd.Series, asset2: pd.Series, 
                          strategy_func, start_date, end_date) -> BacktestResult:
        
        # 1. Prepara dados com cuidados realistas
        data = self._prepare_realistic_data(asset1, asset2, start_date, end_date)
        
        # 2. Simula execução dia a dia
        portfolio_values = []
        trades = []
        current_position = {'asset1': 0, 'asset2': 0}
        cash = self.initial_capital
        
        for date in data.index:
            # Gera sinal apenas com dados disponíveis até esta data
            historical_data = data.loc[:date]
            signal = strategy_func(historical_data)
            
            # Executa trades com custos realistas
            if signal != 0:
                trade_result = self._execute_trade(signal, date, data.loc[date], current_position, cash)
                trades.append(trade_result)
                current_position = trade_result['new_position']
                cash = trade_result['new_cash']
            
            # Calcula valor do portfolio
            portfolio_value = self._calculate_portfolio_value(current_position, cash, data.loc[date])
            portfolio_values.append({'date': date, 'value': portfolio_value})
        
        # 3. Calcula métricas robustas
        return self._calculate_metrics(portfolio_values, trades)
    
    def _prepare_realistic_data(self, asset1, asset2, start_date, end_date):
        """Adiciona bid-ask spreads, gaps, e outros fatores realistas"""
        data = pd.DataFrame({
            'asset1': asset1,
            'asset2': asset2,
        })
        
        # Simula bid-ask spread (0.1% típico para ações líquidas)
        data['asset1_bid'] = data['asset1'] * 0.999
        data['asset1_ask'] = data['asset1'] * 1.001
        data['asset2_bid'] = data['asset2'] * 0.999
        data['asset2_ask'] = data['asset2'] * 1.001
        
        # Remove fins de semana e feriados
        data = data[data.index.dayofweek < 5]
        
        return data[start_date:end_date]
    
    def _execute_trade(self, signal, date, prices, current_position, cash):
        """Simula execução realista com slippage e comissões"""
        
        # Calcula tamanho da posição baseado em volatilidade
        volatility = self._calculate_recent_volatility(prices)
        position_size = self._calculate_position_size(cash, volatility)
        
        # Executa com preços realistas (bid para venda, ask para compra)
        if signal > 0:  # Long asset1, Short asset2
            asset1_price = prices['asset1_ask']  # Compra pelo ask
            asset2_price = prices['asset2_bid']  # Venda pelo bid
        else:  # Short asset1, Long asset2
            asset1_price = prices['asset1_bid']  # Venda pelo bid
            asset2_price = prices['asset2_ask']  # Compra pelo ask
        
        # Calcula custos
        commission_cost = position_size * self.commission * 2  # Ambos os lados
        slippage_cost = position_size * 0.0005  # 0.05% de slippage
        
        total_cost = commission_cost + slippage_cost
        
        return {
            'date': date,
            'signal': signal,
            'position_size': position_size,
            'total_cost': total_cost,
            'new_position': {'asset1': signal * position_size, 'asset2': -signal * position_size},
            'new_cash': cash - total_cost
        }

def calculate_advanced_metrics(returns: pd.Series) -> Dict:
    """Métricas que hedge funds usam de verdade"""
    
    # Básicas
    total_return = (returns + 1).prod() - 1
    annual_return = (1 + total_return) ** (252 / len(returns)) - 1
    volatility = returns.std() * np.sqrt(252)
    sharpe_ratio = annual_return / volatility
    
    # Avançadas - as que realmente importam
    downside_deviation = returns[returns < 0].std() * np.sqrt(252)
    sortino_ratio = annual_return / downside_deviation
    
    # Drawdown detalhado
    cumulative = (1 + returns).cumprod()
    rolling_max = cumulative.expanding().max()
    drawdowns = (cumulative - rolling_max) / rolling_max
    max_drawdown = drawdowns.min()
    avg_drawdown = drawdowns[drawdowns < 0].mean()
    drawdown_duration = calculate_drawdown_duration(drawdowns)
    
    # Tail risk
    var_95 = returns.quantile(0.05)  # Value at Risk 95%
    cvar_95 = returns[returns <= var_95].mean()  # Conditional VaR
    
    # Consistency
    monthly_returns = returns.resample('M').apply(lambda x: (1 + x).prod() - 1)
    win_rate = (monthly_returns > 0).mean()
    
    return {
        'annual_return': annual_return,
        'sharpe_ratio': sharpe_ratio,
        'sortino_ratio': sortino_ratio,
        'max_drawdown': max_drawdown,
        'avg_drawdown': avg_drawdown,
        'var_95': var_95,
        'cvar_95': cvar_95,
        'win_rate': win_rate,
        'profit_factor': calculate_profit_factor(returns)
    }

def walk_forward_analysis(data, strategy_func, train_months=24, test_months=6):
    """
    Testa a estratégia de forma mais realista:
    - Treina com 24 meses de dados
    - Testa nos próximos 6 meses
    - Move a janela e repete
    """
    results = []
    
    start_date = data.index[0]
    end_date = data.index[-1]
    
    current_date = start_date + pd.DateOffset(months=train_months)
    
    while current_date + pd.DateOffset(months=test_months) <= end_date:
        # Período de treino
        train_start = current_date - pd.DateOffset(months=train_months)
        train_end = current_date
        train_data = data[train_start:train_end]
        
        # Otimiza parâmetros no período de treino
        best_params = optimize_strategy(train_data, strategy_func)
        
        # Testa no período seguinte
        test_start = current_date
        test_end = current_date + pd.DateOffset(months=test_months)
        test_data = data[test_start:test_end]
        
        test_result = backtest_strategy(test_data, strategy_func, best_params)
        results.append({
            'test_period': f"{test_start.date()} to {test_end.date()}",
            'return': test_result.total_return,
            'sharpe': test_result.sharpe_ratio,
            'max_dd': test_result.max_drawdown
        })
        
        # Move janela para frente
        current_date += pd.DateOffset(months=test_months)
    
    return pd.DataFrame(results)

class ExecutionRiskManager:
    def __init__(self):
        self.slippage_tracker = []
        self.execution_delays = []
        self.partial_fills = []
    
    def monitor_execution_quality(self, intended_price, executed_price, intended_size, executed_size, timestamp):
        """Monitora qualidade de execução em tempo real"""
        
        # Calcula slippage
        slippage = abs(executed_price - intended_price) / intended_price
        self.slippage_tracker.append(slippage)
        
        # Monitora fills parciais
        fill_ratio = executed_size / intended_size
        if fill_ratio < 0.95:  # Less than 95% filled
            self.partial_fills.append({
                'timestamp': timestamp,
                'fill_ratio': fill_ratio,
                'market_impact': self.estimate_market_impact(intended_size)
            })
        
        # Alerta se execução está degradando
        if len(self.slippage_tracker) > 100:
            recent_slippage = np.mean(self.slippage_tracker[-50:])
            historical_slippage = np.mean(self.slippage_tracker[:-50])
            
            if recent_slippage > historical_slippage * 1.5:
                self.send_alert("EXECUTION QUALITY DEGRADING", 
                              f"Recent slippage: {recent_slippage:.4f}")
    
    def dynamic_position_sizing(self, intended_size, current_liquidity):
        """Ajusta tamanho da posição baseado na liquidez atual"""
        
        # Nunca opere mais que 10% do volume médio diário
        max_safe_size = current_liquidity * 0.10
        
        if intended_size > max_safe_size:
            return max_safe_size, "SIZE_REDUCED_LIQUIDITY"
        
        return intended_size, "SIZE_OK"

class ModelDegradationDetector:
    def __init__(self, model, lookback_window=60):
        self.model = model
        self.lookback_window = lookback_window
        self.performance_history = []
        
    def detect_model_decay(self, recent_returns, expected_returns):
        """Detecta quando modelo está perdendo poder preditivo"""
        
        # Calcula correlação entre predições e retornos reais
        correlation = np.corrcoef(recent_returns, expected_returns)[0,1]
        self.performance_history.append(correlation)
        
        if len(self.performance_history) > self.lookback_window:
            # Compara performance recente vs histórica
            recent_perf = np.mean(self.performance_history[-20:])
            historical_perf = np.mean(self.performance_history[:-20])
            
            degradation = (historical_perf - recent_perf) / historical_perf
            
            if degradation > 0.30:  # 30% worse performance
                return {
                    'status': 'MODEL_DECAY_DETECTED',
                    'degradation_pct': degradation,
                    'recommendation': 'REDUCE_POSITION_SIZES'
                }
        
        return {'status': 'MODEL_OK'}
    
    def regime_change_detection(self, market_data):
        """Detecta mudanças de regime de mercado"""
        
        # Calcula volatilidade rolling
        volatility = market_data.rolling(30).std()
        
        # Detecta breakouts de volatilidade
        vol_zscore = (volatility.iloc[-1] - volatility.mean()) / volatility.std()
        
        if abs(vol_zscore) > 2.5:  # Mudança significativa
            return {
                'regime_change': True,
                'new_vol_regime': 'HIGH' if vol_zscore > 0 else 'LOW',
                'confidence': min(abs(vol_zscore) / 2.5, 1.0)
            }
        
        return {'regime_change': False}

class SystemicRiskMonitor:
    def __init__(self):
        self.correlation_threshold = 0.85
        self.vix_threshold = 30
        self.drawdown_threshold = 0.15
        
    def monitor_correlation_breakdown(self, asset_returns):
        """Monitora quando correlações se tornam muito altas"""
        
        # Calcula correlação rolling de todos os pares
        correlations = asset_returns.rolling(30).corr()
        
        # Identifica quando muitos pares ficam altamente correlacionados
        high_corr_pairs = 0
        total_pairs = 0
        
        for i in range(len(asset_returns.columns)):
            for j in range(i+1, len(asset_returns.columns)):
                corr = correlations.iloc[-1].iloc[i, j]
                if not np.isnan(corr):
                    total_pairs += 1
                    if abs(corr) > self.correlation_threshold:
                        high_corr_pairs += 1
        
        correlation_crisis_ratio = high_corr_pairs / total_pairs if total_pairs > 0 else 0
        
        if correlation_crisis_ratio > 0.70:  # 70% dos pares altamente correlacionados
            return {
                'status': 'CORRELATION_CRISIS',
                'affected_pairs_pct': correlation_crisis_ratio,
                'recommendation': 'REDUCE_ALL_POSITIONS'
            }
        
        return {'status': 'CORRELATIONS_NORMAL'}
    
    def calculate_portfolio_var(self, positions, returns_covariance):
        """Calcula Value at Risk do portfolio"""
        
        # Converte posições para array
        weights = np.array(list(positions.values()))
        
        # Calcula VaR 95% (1 dia)
        portfolio_variance = np.dot(weights.T, np.dot(returns_covariance, weights))
        portfolio_std = np.sqrt(portfolio_variance)
        
        # VaR 95% = 1.645 * standard deviation
        var_95 = 1.645 * portfolio_std
        
        return var_95

class DynamicRiskManager:
    def __init__(self, max_portfolio_risk=0.02, max_single_position=0.05):
        self.max_portfolio_risk = max_portfolio_risk  # 2% max risk per day
        self.max_single_position = max_single_position  # 5% max per position
        self.risk_budget_used = 0
        
    def calculate_position_size(self, expected_return, volatility, confidence):
        """Kelly Criterion modificado para position sizing"""
        
        # Kelly básico: f = (bp - q) / b
        # onde b = odds, p = prob. win, q = prob. loss
        
        win_prob = confidence
        loss_prob = 1 - confidence
        avg_win = abs(expected_return) if expected_return > 0 else 0.01
        avg_loss = volatility * 2  # Assume perda de 2 desvios padrão
        
        if avg_loss == 0:
            return 0
            
        kelly_fraction = (win_prob * avg_win - loss_prob * avg_loss) / avg_loss
        
        # Aplica limitadores de segurança
        kelly_fraction = max(0, min(kelly_fraction, 0.25))  # Max 25% Kelly
        
        # Considera risco já utilizado no portfolio
        available_risk_budget = self.max_portfolio_risk - self.risk_budget_used
        position_size = min(kelly_fraction, available_risk_budget, self.max_single_position)
        
        return position_size
    
    def emergency_risk_reduction(self, current_drawdown, market_stress_level):
        """Reduz exposição automaticamente em situações de stress"""
        
        risk_reduction_factor = 1.0
        
        # Baseado no drawdown atual
        if current_drawdown > 0.05:  # 5% drawdown
            risk_reduction_factor *= 0.8
        if current_drawdown > 0.10:  # 10% drawdown  
            risk_reduction_factor *= 0.6
        if current_drawdown > 0.15:  # 15% drawdown
            risk_reduction_factor *= 0.4
        
        # Baseado no stress do mercado
        if market_stress_level > 0.7:  # Alto stress
            risk_reduction_factor *= 0.7
        if market_stress_level > 0.9:  # Stress extremo
            risk_reduction_factor *= 0.3
        
        return risk_reduction_factor
    
    def portfolio_heat_check(self, positions, market_data):
        """Verifica se portfolio está 'muito quente'"""
        
        alerts = []
        
        # 1. Concentração excessiva
        position_values = list(positions.values())
        largest_position = max(position_values) / sum(position_values)
        if largest_position > 0.30:
            alerts.append("CONCENTRATION_RISK: Single position > 30%")
        
        # 2. Correlação de posições muito alta
        if len(positions) > 1:
            correlations = calculate_position_correlations(positions, market_data)
            avg_correlation = correlations.mean().mean()
            if avg_correlation > 0.70:
                alerts.append("HIGH_CORRELATION: Average correlation > 70%")
        
        # 3. Drawdown acelerando
        recent_returns = calculate_portfolio_returns(positions, market_data)
        if len(recent_returns) >= 10:
            recent_dd = calculate_drawdown(recent_returns[-10:])
            older_dd = calculate_drawdown(recent_returns[-20:-10])
            if recent_dd > older_dd * 1.5:
                alerts.append("ACCELERATING_DRAWDOWN")
        
        return alerts

def create_emergency_protocols():
    """Protocolos automáticos para diferentes cenários de crise"""
    
    protocols = {
        'FLASH_CRASH': {
            'trigger': 'market_drop > 5% in 30min',
            'actions': [
                'close_all_momentum_positions',
                'reduce_mean_reversion_by_50%',
                'increase_cash_buffer_to_20%'
            ]
        },
        
        'VOLATILITY_SPIKE': {
            'trigger': 'vix > 40 or realized_vol > 2x_normal',
            'actions': [
                'reduce_all_positions_by_30%',
                'widen_stop_losses',
                'suspend_new_entries_for_24h'
            ]
        },
        
        'CORRELATION_BREAKDOWN': {
            'trigger': 'avg_correlation > 0.85 across 70% of pairs',
            'actions': [
                'close_weakest_performing_positions',
                'keep_only_highest_conviction_trades',
                'increase_monitoring_frequency'
            ]
        },
        
        'EXECUTION_DEGRADATION': {
            'trigger': 'slippage > 2x_historical_average for 1hour',
            'actions': [
                'reduce_position_sizes_by_50%',
                'increase_time_between_trades',
                'switch_to_more_liquid_instruments'
            ]
        }
    }
    
    return protocols

def calculate_real_time_risk_metrics(portfolio, market_data):
    """Dashboard de risco em tempo real"""
    
    metrics = {}
    
    # 1. VaR Portfolio (1 dia, 95% confiança)
    metrics['portfolio_var_1d'] = calculate_portfolio_var(portfolio, market_data)
    
    # 2. Expected Shortfall (perda esperada além do VaR)
    metrics['expected_shortfall'] = calculate_expected_shortfall(portfolio, market_data)
    
    # 3. Maximum Adverse Excursion atual
    metrics['current_mae'] = calculate_current_mae(portfolio)
    
    # 4. Correlation stress (correlação média vs histórica)
    metrics['correlation_stress'] = calculate_correlation_stress(portfolio, market_data)
    
    # 5. Liquidity risk (tempo estimado para liquidar portfolio)
    metrics['liquidation_time_estimate'] = estimate_liquidation_time(portfolio)
    
    # 6. Model confidence (quão confiante o modelo está)
    metrics['model_confidence'] = calculate_model_confidence(portfolio, market_data)
    
    return metrics

# main_trading_system.py
import asyncio
import logging
from datetime import datetime, time
import pandas as pd
from typing import Dict, List
import json

class AutomatedTradingSystem:
    def __init__(self, config_file='trading_config.json'):
        self.config = self.load_config(config_file)
        self.is_running = False
        self.positions = {}
        self.market_data = {}
        self.risk_manager = DynamicRiskManager()
        self.execution_engine = ExecutionEngine()
        self.strategy_manager = StrategyManager()
        
        # Setup logging
        logging.basicConfig(
            level=logging.INFO,
            format='%(asctime)s - %(levelname)s - %(message)s',
            handlers=[
                logging.FileHandler('trading_system.log'),
                logging.StreamHandler()
            ]
        )
        self.logger = logging.getLogger(__name__)
    
    async def start_system(self):
        """Inicia sistema completo de trading"""
        self.logger.info("🚀 Starting Automated Trading System")
        
        # Verificações iniciais de segurança
        if not await self.pre_flight_checks():
            self.logger.error("❌ Pre-flight checks failed")
            return False
        
        self.is_running = True
        
        # Cria tasks assíncronas para diferentes componentes
        tasks = [
            asyncio.create_task(self.market_data_loop()),
            asyncio.create_task(self.strategy_execution_loop()),
            asyncio.create_task(self.risk_monitoring_loop()),
            asyncio.create_task(self.portfolio_reporting_loop()),
            asyncio.create_task(self.heartbeat_loop())
        ]
        
        try:
            await asyncio.gather(*tasks)
        except Exception as e:
            self.logger.error(f"💥 System error: {e}")
            await self.emergency_shutdown()
    
    async def pre_flight_checks(self) -> bool:
        """Verificações críticas antes de iniciar"""
        checks = {
            'broker_connection': await self.test_broker_connection(),
            'market_data_feed': await self.test_market_data(),
            'risk_limits': self.validate_risk_parameters(),
            'portfolio_sync': await self.sync_portfolio_positions(),
            'trading_hours': self.check_trading_hours()
        }
        
        for check_name, result in checks.items():
            if not result:
                self.logger.error(f"❌ Failed: {check_name}")
                return False
            else:
                self.logger.info(f"✅ Passed: {check_name}")
        
        return True
    
    async def market_data_loop(self):
        """Loop principal de coleta de dados"""
        while self.is_running:
            try:
                # Coleta dados de todos os instrumentos
                for symbol in self.config['universe']:
                    current_data = await self.get_real_time_data(symbol)
                    self.market_data[symbol] = current_data
                
                # Calcula indicadores derivados
                self.calculate_derived_indicators()
                
                await asyncio.sleep(1)  # Update every second
                
            except Exception as e:
                self.logger.error(f"Market data error: {e}")
                await asyncio.sleep(5)  # Wait before retry
    
    async def strategy_execution_loop(self):
        """Loop de execução das estratégias"""
        while self.is_running:
            try:
                if not self.is_market_open():
                    await asyncio.sleep(60)  # Check every minute when closed
                    continue
                
                # Para cada estratégia ativa
                for strategy_id, strategy in self.strategy_manager.active_strategies.items():
                    
                    # Gera sinais baseado nos dados atuais
                    signals = strategy.generate_signals(self.market_data)
                    
                    # Para cada sinal gerado
                    for signal in signals:
                        if self.validate_signal(signal):
                            await self.process_trading_signal(signal)
                
                await asyncio.sleep(self.config['strategy_check_interval'])
                
            except Exception as e:
                self.logger.error(f"Strategy execution error: {e}")
                await asyncio.sleep(30)
    
    async def process_trading_signal(self, signal):
        """Processa sinal de trading com todos os checks"""
        
        # 1. Risk check
        risk_approved = self.risk_manager.validate_signal(signal, self.positions)
        if not risk_approved:
            self.logger.warning(f"🚫 Signal rejected by risk manager: {signal}")
            return
        
        # 2. Position sizing
        position_size = self.risk_manager.calculate_position_size(
            signal['expected_return'],
            signal['volatility'],
            signal['confidence']
        )
        
        # 3. Execution
        if position_size > 0:
            execution_result = await self.execution_engine.execute_signal({
                **signal,
                'size': position_size
            })
            
            if execution_result['status'] == 'FILLED':
                self.update_positions(execution_result)
                self.send_notification(f"✅ Executed: {signal['pair']} - Size: {position_size}")
            else:
                self.logger.warning(f"⚠️ Execution failed: {execution_result}")
    
    async def risk_monitoring_loop(self):
        """Monitoramento contínuo de risco"""
        while self.is_running:
            try:
                # Calcula métricas de risco atuais
                risk_metrics = self.risk_manager.calculate_real_time_metrics(
                    self.positions, self.market_data
                )
                
                # Verifica alertas
                alerts = self.risk_manager.check_risk_alerts(risk_metrics)
                
                for alert in alerts:
                    await self.handle_risk_alert(alert)
                
                # Atualiza dashboard
                self.update_risk_dashboard(risk_metrics)
                
                await asyncio.sleep(30)  # Check every 30 seconds
                
            except Exception as e:
                self.logger.error(f"Risk monitoring error: {e}")
                await asyncio.sleep(60)
    
    async def handle_risk_alert(self, alert):
        """Responde automaticamente a alertas de risco"""
        
        alert_type = alert['type']
        severity = alert['severity']
        
        if severity == 'CRITICAL':
            # Ação imediata necessária
            if alert_type == 'MAX_DRAWDOWN_EXCEEDED':
                await self.emergency_position_reduction(0.5)  # Reduz 50% das posições
            elif alert_type == 'CORRELATION_CRISIS':
                await self.close_weakest_positions()
            elif alert_type == 'EXECUTION_DEGRADED':
                self.temporarily_disable_new_entries()
        
        elif severity == 'HIGH':
            # Ações preventivas
            if alert_type == 'HIGH_PORTFOLIO_HEAT':
                await self.reduce_position_sizes(0.8)  # Reduz para 80% do tamanho atual
            elif alert_type == 'MODEL_DEGRADATION':
                self.reduce_strategy_confidence(alert['strategy_id'], 0.7)
        
        # Sempre notifica
        self.send_notification(f"🚨 RISK ALERT: {alert_type} - {alert['message']}")

class ExecutionEngine:
    def __init__(self, broker_config):
        self.broker = self.connect_to_broker(broker_config)
        self.order_book = {}
        self.execution_stats = {
            'total_orders': 0,
            'successful_fills': 0,
            'average_slippage': 0,
            'average_execution_time': 0
        }
    
    async def execute_signal(self, signal):
        """Executa sinal com máxima robustez"""
        
        start_time = datetime.now()
        
        try:
            # 1. Valida condições de mercado
            market_condition = await self.assess_market_conditions(signal['symbols'])
            if market_condition['liquidity_score'] < 0.5:
                return {'status': 'REJECTED', 'reason': 'INSUFFICIENT_LIQUIDITY'}
            
            # 2. Calcula preços de execução esperados
            expected_prices = await self.get_expected_execution_prices(signal['symbols'])
            
            # 3. Cria ordens com proteções
            orders = self.create_protected_orders(signal, expected_prices)
            
            # 4. Executa com timeout e retry logic
            execution_results = await self.execute_orders_with_retry(orders)
            
            # 5. Valida execução
            validation_result = self.validate_execution(execution_results, signal)
            
            if validation_result['is_valid']:
                self.update_execution_stats(execution_results, start_time)
                return {
                    'status': 'FILLED',
                    'execution_details': execution_results,
                    'slippage': validation_result['slippage'],
                    'execution_time': (datetime.now() - start_time).total_seconds()
                }
            else:
                # Rollback parcial execution if needed
                await self.rollback_partial_execution(execution_results)
                return {'status': 'FAILED', 'reason': validation_result['failure_reason']}
        
        except Exception as e:
            self.logger.error(f"Execution error: {e}")
            return {'status': 'ERROR', 'reason': str(e)}
    
    def create_protected_orders(self, signal, expected_prices):
        """Cria ordens com múltiplas proteções"""
        
        orders = []
        
        # Para estratégias long/short, cria ordens simultâneas
        if signal['type'] == 'PAIRS_TRADE':
            
            # Ordem Long
            long_order = {
                'symbol': signal['long_symbol'],
                'side': 'BUY',
                'quantity': signal['size'],
                'order_type': 'LIMIT',
                'price': expected_prices[signal['long_symbol']]['ask'] * 1.001,  # Pequeno buffer
                'time_in_force': 'IOC',  # Immediate or Cancel
                'stop_loss': expected_prices[signal['long_symbol']]['ask'] * (1 - signal['stop_loss_pct']),
                'take_profit': expected_prices[signal['long_symbol']]['ask'] * (1 + signal['take_profit_pct'])
            }
            
            # Ordem Short (simultânea)
            short_order = {
                'symbol': signal['short_symbol'],
                'side': 'SELL',
                'quantity': signal['size'],
                'order_type': 'LIMIT',
                'price': expected_prices[signal['short_symbol']]['bid'] * 0.999,  # Pequeno buffer
                'time_in_force': 'IOC',
                'stop_loss': expected_prices[signal['short_symbol']]['bid'] * (1 + signal['stop_loss_pct']),
                'take_profit': expected_prices[signal['short_symbol']]['bid'] * (1 - signal['take_profit_pct'])
            }
            
            orders = [long_order, short_order]
        
        return orders
    
    async def execute_orders_with_retry(self, orders, max_retries=3):
        """Executa ordens com logic de retry inteligente"""
        
        results = []
        
        for order in orders:
            retry_count = 0
            order_filled = False
            
            while retry_count < max_retries and not order_filled:
                try:
                    # Executa ordem
                    result = await self.broker.place_order(order)
                    
                    if result['status'] == 'FILLED':
                        results.append(result)
                        order_filled = True
                    elif result['status'] == 'PARTIAL_FILL':
                        # Ajusta ordem para quantidade restante
                        remaining_qty = order['quantity'] - result['filled_quantity']
                        if remaining_qty > 0:
                            order['quantity'] = remaining_qty
                            retry_count += 1
                    else:
                        # Ordem rejeitada - ajusta preço e tenta novamente
                        order = self.adjust_order_for_retry(order, result['rejection_reason'])
                        retry_count += 1
                
                except Exception as e:
                    self.logger.warning(f"Order execution attempt {retry_count + 1} failed: {e}")
                    retry_count += 1
                    await asyncio.sleep(0.5)  # Wait before retry
            
            if not order_filled:
                results.append({'status': 'FAILED', 'symbol': order['symbol']})
        
        return results

class MonitoringSystem:
    def __init__(self):
        self.telegram_bot = TelegramBot()
        self.email_alerts = EmailAlerts()
        self.dashboard = TradingDashboard()
        self.metrics_collector = MetricsCollector()
    
    def send_notification(self, message, severity='INFO'):
        """Sistema unificado de notificações"""
        
        timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
        formatted_message = f"[{timestamp}] {message}"
        
        # Console log
        if severity == 'CRITICAL':
            self.logger.critical(formatted_message)
        elif severity == 'ERROR':
            self.logger.error(formatted_message)
        elif severity == 'WARNING':
            self.logger.warning(formatted_message)
        else:
            self.logger.info(formatted_message)
        
        # Telegram (tempo real)
        self.telegram_bot.send_message(formatted_message)
        
        # Email (apenas alerts importantes)
        if severity in ['CRITICAL', 'ERROR']:
            self.email_alerts.send_alert(message, severity)
        
        # Dashboard update
        self.dashboard.add_log_entry(formatted_message, severity)
    
    def generate_daily_report(self, positions, trades, performance):
        """Relatório automático diário"""
        
        report = f"""
        📊 DAILY TRADING REPORT - {datetime.now().strftime('%Y-%m-%d')}
        
        💰 PERFORMANCE
        Daily P&L: {performance['daily_pnl']:+.2f}%
        Total Return: {performance['total_return']:+.2f}%
        Sharpe Ratio: {performance['sharpe_ratio']:.2f}
        Max Drawdown: {performance['max_drawdown']:.2f}%
        
        📈 TRADES TODAY
        Total Trades: {len(trades)}
        Winning Trades: {len([t for t in trades if t['pnl'] > 0])}
        Win Rate: {len([t for t in trades if t['pnl'] > 0])/len(trades)*100:.1f}%
        Average Trade: {np.mean([t['pnl'] for t in trades]):.2f}%
        
        🎯 ACTIVE POSITIONS
        Total Positions: {len(positions)}
        Long Exposure: {sum([p['value'] for p in positions.values() if p['side'] == 'LONG']):.0f}
        Short Exposure: {sum([p['value'] for p in positions.values() if p['side'] == 'SHORT']):.0f}
        Net Exposure: {performance['net_exposure']:.1f}%
        
        ⚠️ RISK METRICS
        Portfolio VaR (1d): {performance['var_1d']:.2f}%
        Current Drawdown: {performance['current_drawdown']:.2f}%
        Risk Budget Used: {performance['risk_budget_used']:.1f}%
        
        🔧 SYSTEM STATUS
        Uptime: {performance['system_uptime']}
        Data Quality: {performance['data_quality_score']:.1f}%
        Execution Quality: {performance['execution_quality_score']:.1f}%
        """
        
        self.send_notification(report, 'INFO')
        return report

# trading_config.json
{
    "universe": [
        "PETR4.SA", "VALE3.SA", "ITUB4.SA", "BBDC4.SA",
        "ABEV3.SA", "MGLU3.SA", "WEGE3.SA", "RENT3.SA"
    ],
    
    "strategies": {
        "pairs_trading": {
            "enabled": true,
            "pairs": [
                {"asset1": "PETR4.SA", "asset2": "PRIO3.SA", "weight": 0.3},
                {"asset1": "ITUB4.SA", "asset2": "BBDC4.SA", "weight": 0.3},
                {"asset1": "VALE3.SA", "asset2": "CSNA3.SA", "weight": 0.4}
            ],
            "parameters": {
                "lookback_window": 60,
                "entry_zscore": 2.0,
                "exit_zscore": 0.5,
                "max_holding_period": 30
            }
        }
    },
    
    "risk_management": {
        "max_portfolio_risk_per_day": 0.02,
        "max_single_position_size": 0.05,
        "max_portfolio_drawdown": 0.15,
        "position_sizing_method": "kelly_modified",
        "emergency_protocols": {
            "market_crash_threshold": 0.05,
            "correlation_crisis_threshold": 0.85,
            "execution_degradation_threshold": 2.0
        }
    },
    
    "execution": {
        "broker": "interactive_brokers",
        "order_type": "limit_with_protection",
        "max_slippage_tolerance": 0.002,
        "execution_timeout": 30,
        "retry_attempts": 3
    },
    
    "monitoring": {
        "telegram_bot_token": "YOUR_BOT_TOKEN",
        "telegram_chat_id": "YOUR_CHAT_ID",
        "email_alerts": true,
        "daily_report_time": "18:00",
        "heartbeat_interval": 60
    }
}

#!/bin/bash
# deploy_trading_system.sh

echo "🚀 Deploying Automated Trading System..."

# 1. Setup virtual environment
python -m venv trading_env
source trading_env/bin/activate

# 2. Install dependencies
pip install -r requirements.txt

# 3. Setup configuration
cp config/trading_config.template.json config/trading_config.json
echo "⚠️  Please edit config/trading_config.json with your parameters"

# 4. Setup database
python setup_database.py

# 5. Run initial tests
python -m pytest tests/ -v

# 6. Setup systemd service (Linux)
sudo cp scripts/trading_system.service /etc/systemd/system/
sudo systemctl daemon-reload
sudo systemctl enable trading_system.service

echo "✅ Deployment complete!"
echo "📝 Next steps:"
echo "   1. Edit config/trading_config.json"
echo "   2. Test with paper trading: python main.py --paper-trading"
echo "   3. Start live trading: sudo systemctl start trading_system"

def calculate_realistic_expectations(capital, experience_level, time_horizon_months):
    """Calcula expectativas realistas baseadas em dados históricos"""
    
    performance_profiles = {
        'beginner': {
            'annual_return_range': (0.08, 0.15),  # 8-15% ao ano
            'max_drawdown_expected': 0.12,         # 12% drawdown típico
            'win_rate': 0.55,                      # 55% dos trades profitable
            'sharpe_ratio': (0.8, 1.2),           # Sharpe moderado
            'learning_curve_months': 6,            # 6 meses para estabilizar
            'breakeven_probability': 0.70          # 70% chance de ser profitable
        },
        
        'intermediate': {
            'annual_return_range': (0.15, 0.25),  # 15-25% ao ano
            'max_drawdown_expected': 0.15,
            'win_rate': 0.60,
            'sharpe_ratio': (1.2, 1.8),
            'learning_curve_months': 12,
            'breakeven_probability': 0.85
        },
        
        'advanced': {
            'annual_return_range': (0.20, 0.40),  # 20-40% ao ano
            'max_drawdown_expected': 0.20,
            'win_rate': 0.65,
            'sharpe_ratio': (1.5, 2.5),
            'learning_curve_months': 18,
            'breakeven_probability': 0.90
        }
    }
    
    profile = performance_profiles[experience_level]
    
    # Ajusta para capital (fundos maiores têm returns menores devido à capacidade)
    capital_adjustment = min(1.0, 100000 / capital) ** 0.1
    
    expected_annual_return = np.mean(profile['annual_return_range']) * capital_adjustment
    monthly_return = (1 + expected_annual_return) ** (1/12) - 1
    
    # Calcula projeção
    projected_values = [capital]
    for month in range(time_horizon_months):
        # Adiciona volatilidade realista
        monthly_vol = 0.03  # 3% de vol mensal típica
        random_return = np.random.normal(monthly_return, monthly_vol)
        projected_values.append(projected_values[-1] * (1 + random_return))
    
    return {
        'expected_annual_return': expected_annual_return,
        'projected_final_value': projected_values[-1],
        'max_drawdown_expected': profile['max_drawdown_expected'],
        'months_to_statistical_significance': profile['learning_curve_months'],
        'probability_of_profitability': profile['breakeven_probability']
    }

def monte_carlo_performance_simulation(initial_capital=50000, num_simulations=1000):
    """Simula milhares de cenários possíveis"""
    
    results = []
    
    for simulation in range(num_simulations):
        # Parâmetros aleatórios dentro de ranges realistas
        annual_return = np.random.normal(0.18, 0.08)  # Média 18%, vol 8%
        annual_vol = np.random.uniform(0.12, 0.25)    # Vol entre 12-25%
        max_drawdown = np.random.uniform(0.10, 0.30)  # DD entre 10-30%
        
        # Simula 3 anos de performance
        monthly_returns = []
        current_value = initial_capital
        peak_value = initial_capital
        max_dd_experienced = 0
        
        for month in range(36):
            # Return mensal com fat tails (distribuição t-student)
            monthly_return = np.random.standard_t(3) * (annual_vol / np.sqrt(12)) + (annual_return / 12)
            
            current_value *= (1 + monthly_return)
            peak_value = max(peak_value, current_value)
            current_dd = (peak_value - current_value) / peak_value
            max_dd_experienced = max(max_dd_experienced, current_dd)
            
            monthly_returns.append(monthly_return)
        
        # Calcula métricas finais
        total_return = (current_value / initial_capital) - 1
        annualized_return = (current_value / initial_capital) ** (1/3) - 1
        sharpe_ratio = np.mean(monthly_returns) / np.std(monthly_returns) * np.sqrt(12)
        
        results.append({
            'final_value': current_value,
            'total_return': total_return,
            'annualized_return': annualized_return,
            'max_drawdown': max_dd_experienced,
            'sharpe_ratio': sharpe_ratio
        })
    
    return pd.DataFrame(results)

# Roda simulação
simulation_results = monte_carlo_performance_simulation()

# Análise dos resultados
print("📊 ANÁLISE DE CENÁRIOS (1000 simulações, 3 anos)")
print(f"Probabilidade de lucro: {(simulation_results['total_return'] > 0).mean():.1%}")
print(f"Retorno mediano anualizado: {simulation_results['annualized_return'].median():.1%}")
print(f"Melhor caso (95º percentil): {simulation_results['annualized_return'].quantile(0.95):.1%}")
print(f"Pior caso (5º percentil): {simulation_results['annualized_return'].quantile(0.05):.1%}")
print(f"Drawdown médio máximo: {simulation_results['max_drawdown'].mean():.1%}")

def compare_investment_alternatives(capital=100000, years=5):
    """Compara long/short automatizado com outras alternativas"""
    
    alternatives = {
        'CDI_100%': {
            'annual_return': 0.1275,  # ~12.75% ao ano (Selic atual)
            'volatility': 0.01,       # Praticamente sem risco
            'max_drawdown': 0.0,
            'time_investment': '0 horas/mês'
        },
        
        'Ibovespa_Buy_Hold': {
            'annual_return': 0.105,   # ~10.5% histórico
            'volatility': 0.28,       # 28% vol anual
            'max_drawdown': 0.45,     # 45% em crises
            'time_investment': '2 horas/mês'
        },
        
        'Long_Short_Manual': {
            'annual_return': 0.12,    # Limitado por capacidade humana
            'volatility': 0.15,
            'max_drawdown': 0.25,
            'time_investment': '20 horas/semana'
        },
        
        'Long_Short_Automated': {
            'annual_return': 0.22,    # Target realista
            'volatility': 0.18,
            'max_drawdown': 0.18,
            'time_investment': '5 horas/semana (após setup)'
        }
    }
    
    results = {}
    for name, params in alternatives.items():
        final_value = capital * (1 + params['annual_return']) ** years
        risk_adjusted_return = params['annual_return'] / max(params['volatility'], 0.01)
        
        results[name] = {
            'final_value': final_value,
            'total_return': (final_value / capital) - 1,
            'risk_adjusted_return': risk_adjusted_return,
            'time_investment': params['time_investment']
        }
    
    return results