docs/configuration.md

# ⚙️ Guia de Configuração

## Visão Geral

Este documento descreve todas as opções de configuração disponíveis no Vampire Trading Bot, incluindo configurações de modelos de IA, análise técnica, interface do usuário e performance.

## 📁 Arquivo Principal de Configuração

Todas as configurações estão centralizadas no arquivo `config.py`. Este arquivo contém classes de configuração organizadas por funcionalidade.

### Estrutura do Arquivo

```python
# config.py
class FinancialModels:      # Modelos de IA
class TechnicalAnalysis:    # Análise técnica
class ScoringConfig:        # Pontuação e confiança
class TradingConfig:        # Configurações de trading
class UIConfig:             # Interface do usuário
class RegexPatterns:        # Padrões de extração
class AIConfig:             # Configurações de IA
class AppConfig:            # Configurações gerais
```

## 🤖 Configuração de Modelos de IA

### FinancialModels

```python
class FinancialModels:
    """Modelos de IA para análise financeira."""
    
    # Lista de modelos disponíveis (ordenados por performance/tamanho)
    FINANCIAL_MODELS = [
        "nlptown/bert-base-multilingual-uncased-sentiment",  # Leve, multilíngue
        "cardiffnlp/twitter-roberta-base-sentiment-latest",   # Médio, redes sociais
        "ProsusAI/finbert",                                   # Pesado, financeiro
        "mrm8488/distilroberta-finetuned-financial-news-sentiment-analysis"
    ]
    
    # Modelo padrão (usado se não especificado)
    DEFAULT_MODEL = FINANCIAL_MODELS[0]
    
    # Modelos alternativos para fallback
    FALLBACK_MODELS = [
        "cardiffnlp/twitter-roberta-base-sentiment-latest",
        "nlptown/bert-base-multilingual-uncased-sentiment"
    ]
```

#### Como Configurar

1. **Escolher Modelo por Performance**:
   ```python
   # Para melhor performance (mais leve)
   DEFAULT_MODEL = "nlptown/bert-base-multilingual-uncased-sentiment"
   
   # Para melhor precisão (mais pesado)
   DEFAULT_MODEL = "ProsusAI/finbert"
   ```

2. **Adicionar Novos Modelos**:
   ```python
   FINANCIAL_MODELS.append("seu-modelo/nome-do-modelo")
   ```

### AIConfig

```python
class AIConfig:
    """Configurações gerais de IA."""
    
    # Tamanho máximo de texto para análise
    MAX_TEXT_LENGTH = 512
    
    # Pipeline de análise de sentimento
    SENTIMENT_PIPELINE = "sentiment-analysis"
    
    # Configurações de cache
    ENABLE_MODEL_CACHE = True
    CACHE_SIZE = 100
    
    # Timeout para carregamento de modelos (segundos)
    MODEL_LOAD_TIMEOUT = 60
    
    # Usar GPU se disponível
    USE_GPU = True
    
    # Batch size para processamento
    BATCH_SIZE = 8
```

#### Configurações Avançadas de IA

```python
# Configuração de memória
AIConfig.MAX_TEXT_LENGTH = 256  # Reduzir para economizar memória
AIConfig.BATCH_SIZE = 4         # Reduzir batch size

# Configuração de performance
AIConfig.USE_GPU = False        # Forçar uso de CPU
AIConfig.ENABLE_MODEL_CACHE = False  # Desabilitar cache

# Configuração de timeout
AIConfig.MODEL_LOAD_TIMEOUT = 120  # Aumentar timeout
```

## 📊 Configuração de Análise Técnica

### TechnicalAnalysis

```python
class TechnicalAnalysis:
    """Configurações para análise técnica."""
    
    # Configurações do RSI
    RSI_PERIOD = 14
    RSI_OVERSOLD = 30
    RSI_OVERBOUGHT = 70
    
    # Configurações das Bandas de Bollinger
    BOLLINGER_PERIOD = 20
    BOLLINGER_STD = 2
    
    # Configurações das EMAs
    EMA_FAST_PERIOD = 9
    EMA_SLOW_PERIOD = 21
    
    # Configurações de Volume
    VOLUME_MA_PERIOD = 20
    HIGH_VOLUME_MULTIPLIER = 1.5
    
    # Configurações de Momentum
    MOMENTUM_PERIOD = 10
    MOMENTUM_THRESHOLD = 0.02
```

#### Personalização de Indicadores

```python
# RSI mais sensível
TechnicalAnalysis.RSI_PERIOD = 10
TechnicalAnalysis.RSI_OVERSOLD = 25
TechnicalAnalysis.RSI_OVERBOUGHT = 75

# Bandas de Bollinger mais apertadas
TechnicalAnalysis.BOLLINGER_STD = 1.5

# EMAs mais rápidas
TechnicalAnalysis.EMA_FAST_PERIOD = 5
TechnicalAnalysis.EMA_SLOW_PERIOD = 13
```

## 🎯 Configuração de Trading

### TradingConfig

```python
class TradingConfig:
    """Configurações de trading e gestão de risco."""
    
    # Stop Loss padrão (percentual)
    DEFAULT_STOP_LOSS = 0.5  # 0.5%
    
    # Take Profit padrão (percentual)
    DEFAULT_TAKE_PROFIT = 1.0  # 1.0%
    
    # Relação risco/recompensa mínima
    MIN_RISK_REWARD = 1.5
    
    # Tamanho de posição padrão
    DEFAULT_POSITION_SIZE = 1.0
    
    # Configurações de scalping
    SCALPING_TIMEFRAMES = ["1m", "5m", "15m"]
    SCALPING_MIN_VOLUME = 1000
    
    # Configurações de volatilidade
    LOW_VOLATILITY_THRESHOLD = 0.5
    HIGH_VOLATILITY_THRESHOLD = 2.0
```

#### Estratégias de Risco

```python
# Estratégia conservadora
TradingConfig.DEFAULT_STOP_LOSS = 0.3
TradingConfig.DEFAULT_TAKE_PROFIT = 0.6
TradingConfig.MIN_RISK_REWARD = 2.0

# Estratégia agressiva
TradingConfig.DEFAULT_STOP_LOSS = 0.8
TradingConfig.DEFAULT_TAKE_PROFIT = 1.5
TradingConfig.MIN_RISK_REWARD = 1.2
```

## 🎨 Configuração da Interface

### UIConfig

```python
class UIConfig:
    """Configurações da interface do usuário."""
    
    # Informações do aplicativo
    TITLE = "📈 Vampire Trading Bot"
    SUBTITLE = "Análise Avançada de Mercado com IA"
    DESCRIPTION = "Sistema completo de análise técnica e sentimento"
    
    # Emojis para diferentes ações
    ACTION_EMOJIS = {
        "COMPRAR": "🟢",
        "VENDER": "🔴",
        "AGUARDAR": "🟡",
        "NEUTRO": "⚪"
    }
    
    # Cores para diferentes elementos
    COLORS = {
        "success": "#28a745",
        "danger": "#dc3545",
        "warning": "#ffc107",
        "info": "#17a2b8",
        "primary": "#007bff"
    }
    
    # Mensagens de status
    STATUS_MESSAGES = {
        "loading": "🔄 Processando análise...",
        "success": "✅ Análise concluída com sucesso!",
        "error": "❌ Erro durante a análise",
        "no_data": "⚠️ Nenhum dado fornecido"
    }
```

#### Personalização da Interface

```python
# Tema escuro
UIConfig.COLORS = {
    "success": "#00ff88",
    "danger": "#ff4444",
    "warning": "#ffaa00",
    "info": "#00aaff",
    "primary": "#8800ff"
}

# Personalizar título
UIConfig.TITLE = "🧛 Meu Bot de Trading"
UIConfig.SUBTITLE = "Análise Personalizada"
```

## 🔍 Configuração de Padrões Regex

### RegexPatterns

```python
class RegexPatterns:
    """Padrões regex para extração de dados."""
    
    # Extração de preços
    PRICE_PATTERN = r"Preço.*?([\d,]+\.\d+)"
    
    # Extração de variação
    VARIATION_PATTERN = r"Variação.*?([+-]?[\d,]+\.\d+)"
    
    # Extração de porcentagem
    PERCENTAGE_PATTERN = r"\(([+-]?\d+\.\d+)%\)"
    
    # Extração de volume
    VOLUME_PATTERN = r"Volume.*?(\d+)"
    
    # Extração de RSI
    RSI_PATTERN = r"RSI.*?(\d+\.\d+)"
    
    # Extração de EMAs
    EMA_PATTERN = r"EMA.*?(\d+\.\d+)"
```

#### Personalização de Padrões

```python
# Padrões para formato brasileiro
RegexPatterns.PRICE_PATTERN = r"R\$\s*([\d.]+,\d+)"
RegexPatterns.PERCENTAGE_PATTERN = r"\(([+-]?\d+,\d+)%\)"

# Padrões para outros idiomas
RegexPatterns.PRICE_PATTERN = r"Price.*?([\d,]+\.\d+)"
```

## 📈 Configuração de Pontuação

### ScoringConfig

```python
class ScoringConfig:
    """Configurações de pontuação e confiança."""
    
    # Pesos para diferentes análises
    TECHNICAL_WEIGHT = 0.4
    SENTIMENT_WEIGHT = 0.3
    FIBONACCI_WEIGHT = 0.3
    
    # Thresholds de confiança
    HIGH_CONFIDENCE_THRESHOLD = 80
    MEDIUM_CONFIDENCE_THRESHOLD = 60
    LOW_CONFIDENCE_THRESHOLD = 40
    
    # Multiplicadores de pontuação
    STRONG_SIGNAL_MULTIPLIER = 1.5
    WEAK_SIGNAL_MULTIPLIER = 0.7
    
    # Penalizações
    CONFLICTING_SIGNALS_PENALTY = 0.2
    LOW_VOLUME_PENALTY = 0.1
```

#### Ajuste de Pesos

```python
# Priorizar análise técnica
ScoringConfig.TECHNICAL_WEIGHT = 0.6
ScoringConfig.SENTIMENT_WEIGHT = 0.2
ScoringConfig.FIBONACCI_WEIGHT = 0.2

# Priorizar sentimento
ScoringConfig.TECHNICAL_WEIGHT = 0.2
ScoringConfig.SENTIMENT_WEIGHT = 0.6
ScoringConfig.FIBONACCI_WEIGHT = 0.2
```

## 🚀 Configuração de Performance

### Configurações de Sistema

```python
# Em performance_monitor.py
class PerformanceConfig:
    # Intervalo de coleta de métricas (segundos)
    METRICS_INTERVAL = 5.0
    
    # Histórico máximo de métricas
    MAX_METRICS_HISTORY = 1000
    
    # Thresholds de alerta
    CPU_ALERT_THRESHOLD = 80.0
    MEMORY_ALERT_THRESHOLD = 85.0
    
    # Configurações de otimização
    ENABLE_AUTO_OPTIMIZATION = True
    OPTIMIZATION_INTERVAL = 300  # 5 minutos
```

### Configurações de Cache

```python
# Cache de modelos
MODEL_CACHE_SIZE = 3
MODEL_CACHE_TTL = 3600  # 1 hora

# Cache de análises
ANALYSIS_CACHE_SIZE = 100
ANALYSIS_CACHE_TTL = 300  # 5 minutos
```

## 🔧 Configuração via Variáveis de Ambiente

### Variáveis Suportadas

```bash
# Modelo de IA
export FINBERT_MODEL="ProsusAI/finbert"
export MAX_TEXT_LENGTH="512"

# Performance
export MAX_WORKERS="4"
export ENABLE_GPU="true"
export CACHE_SIZE="1000"

# Logging
export LOG_LEVEL="INFO"
export LOG_FILE="vampire_bot.log"

# Interface
export GRADIO_SERVER_NAME="0.0.0.0"
export GRADIO_SERVER_PORT="7860"
export GRADIO_SHARE="false"

# Real-time
export LOG_FILE_PATH="/path/to/trading.log"
export CHECK_INTERVAL="1.0"
```

### Carregamento de Variáveis

```python
import os
from config import AIConfig, UIConfig

# Carregar configurações do ambiente
AIConfig.MAX_TEXT_LENGTH = int(os.getenv('MAX_TEXT_LENGTH', '512'))
AIConfig.USE_GPU = os.getenv('ENABLE_GPU', 'true').lower() == 'true'

UIConfig.TITLE = os.getenv('APP_TITLE', UIConfig.TITLE)
```

## 📋 Configuração por Perfil

### Perfis Pré-definidos

```python
# profiles.py
class DevelopmentProfile:
    """Perfil para desenvolvimento."""
    DEBUG = True
    LOG_LEVEL = "DEBUG"
    ENABLE_MODEL_CACHE = False
    USE_LIGHTWEIGHT_MODELS = True

class ProductionProfile:
    """Perfil para produção."""
    DEBUG = False
    LOG_LEVEL = "INFO"
    ENABLE_MODEL_CACHE = True
    USE_LIGHTWEIGHT_MODELS = False
    ENABLE_MONITORING = True

class TestingProfile:
    """Perfil para testes."""
    DEBUG = True
    LOG_LEVEL = "WARNING"
    USE_MOCK_MODELS = True
    DISABLE_REAL_TIME = True
```

### Aplicação de Perfis

```python
# app.py
import os
from profiles import DevelopmentProfile, ProductionProfile

profile = os.getenv('APP_PROFILE', 'development')

if profile == 'production':
    config = ProductionProfile()
else:
    config = DevelopmentProfile()

# Aplicar configurações
for attr in dir(config):
    if not attr.startswith('_'):
        setattr(globals()[attr.split('_')[0] + 'Config'], attr, getattr(config, attr))
```

## 🔄 Configuração Dinâmica

### Recarregamento de Configuração

```python
class ConfigManager:
    """Gerenciador de configuração dinâmica."""
    
    @staticmethod
    def reload_config():
        """Recarrega configurações do arquivo."""
        importlib.reload(config)
    
    @staticmethod
    def update_config(section: str, key: str, value: Any):
        """Atualiza configuração específica."""
        config_class = getattr(config, section)
        setattr(config_class, key, value)
    
    @staticmethod
    def get_config(section: str, key: str) -> Any:
        """Obtém valor de configuração."""
        config_class = getattr(config, section)
        return getattr(config_class, key)
```

### Interface de Configuração

```python
# Adicionar à interface Gradio
def create_config_interface():
    with gr.Tab("⚙️ Configurações"):
        with gr.Row():
            model_dropdown = gr.Dropdown(
                choices=FinancialModels.FINANCIAL_MODELS,
                value=FinancialModels.DEFAULT_MODEL,
                label="Modelo de IA"
            )
            
        with gr.Row():
            rsi_period = gr.Number(
                value=TechnicalAnalysis.RSI_PERIOD,
                label="Período RSI"
            )
            
        update_btn = gr.Button("Atualizar Configurações")
        
        update_btn.click(
            fn=update_configurations,
            inputs=[model_dropdown, rsi_period],
            outputs=[]
        )
```

## 📝 Exemplos de Configuração

### Configuração Básica

```python
# config_basic.py
from config import *

# Usar modelo leve
FinancialModels.DEFAULT_MODEL = "nlptown/bert-base-multilingual-uncased-sentiment"

# Configurações conservadoras
TradingConfig.DEFAULT_STOP_LOSS = 0.3
TradingConfig.MIN_RISK_REWARD = 2.0

# Interface simples
UIConfig.TITLE = "Bot de Trading Simples"
```

### Configuração Avançada

```python
# config_advanced.py
from config import *

# Usar modelo mais preciso
FinancialModels.DEFAULT_MODEL = "ProsusAI/finbert"

# Análise técnica mais sensível
TechnicalAnalysis.RSI_PERIOD = 10
TechnicalAnalysis.EMA_FAST_PERIOD = 5

# Trading mais agressivo
TradingConfig.DEFAULT_STOP_LOSS = 0.8
TradingConfig.MIN_RISK_REWARD = 1.2

# Performance otimizada
AIConfig.BATCH_SIZE = 16
AIConfig.ENABLE_MODEL_CACHE = True
```

## 🔍 Troubleshooting de Configuração

### Problemas Comuns

1. **Modelo não carrega**:
   ```python
   # Verificar se modelo existe
   try:
       from transformers import pipeline
       pipeline("sentiment-analysis", model=FinancialModels.DEFAULT_MODEL)
   except Exception as e:
       print(f"Erro ao carregar modelo: {e}")
   ```

2. **Configuração não aplicada**:
   ```python
   # Verificar se configuração foi carregada
   print(f"Modelo atual: {FinancialModels.DEFAULT_MODEL}")
   print(f"RSI período: {TechnicalAnalysis.RSI_PERIOD}")
   ```

3. **Performance baixa**:
   ```python
   # Configurações para melhor performance
   AIConfig.MAX_TEXT_LENGTH = 256
   AIConfig.BATCH_SIZE = 4
   AIConfig.USE_GPU = False
   ```

### Validação de Configuração

```python
def validate_config():
    """Valida configurações atuais."""
    errors = []
    
    # Validar modelo
    if FinancialModels.DEFAULT_MODEL not in FinancialModels.FINANCIAL_MODELS:
        errors.append("Modelo padrão não está na lista de modelos")
    
    # Validar períodos
    if TechnicalAnalysis.RSI_PERIOD < 2:
        errors.append("Período RSI muito baixo")
    
    # Validar trading
    if TradingConfig.DEFAULT_STOP_LOSS <= 0:
        errors.append("Stop loss deve ser positivo")
    
    return errors
```

## 📚 Próximos Passos

- Leia o [Guia do Desenvolvedor](developer-guide.md)
- Consulte a [Referência da API](api-reference.md)
- Veja exemplos em [Troubleshooting](troubleshooting.md)