feat: Refatoração completa do projeto para melhor manutenibilidade

- Reorganizada estrutura de pastas em src/ com separação modular
- Removidos arquivos duplicados e consolidadas funcionalidades
- Atualizada documentação completa (README, arquitetura, changelog)
- Implementado sistema de logging avançado
- Melhorado sistema ensemble de IA
- Atualizadas dependências no requirements.txt
- Criado CHANGELOG.md para rastreamento de versões

CHANGELOG.md

@@ -0,0 +1,53 @@
+# Changelog
+
+Todas as mudanças notáveis neste projeto serão documentadas neste arquivo.
+
+O formato é baseado em [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+e este projeto adere ao [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [2.0.0] - 2024-01-27
+
+### 🎉 Adicionado
+- **Sistema Ensemble de IA**: Implementação de múltiplos modelos (FinBERT, RoBERTa, Custom)
+- **Votação Inteligente**: Sistema de consenso entre modelos para maior precisão
+- **Análise de Mercado Avançada**: Detecção de swing points, zonas de confluência e padrões harmônicos
+- **Sistema de Logging Completo**: Rastreamento detalhado de requisições e respostas
+- **Estrutura Refatorada**: Organização modular em `src/` com separação clara de responsabilidades
+- **Documentação Completa**: Guias de instalação, API, desenvolvimento e troubleshooting
+- **Testes Automatizados**: Suite de testes para garantir qualidade do código
+
+### 🔄 Alterado
+- **Arquitetura do Projeto**: Migração para estrutura modular organizada
+- **Interface do Usuário**: Melhorias na experiência do usuário com Gradio 5.44.0
+- **Performance**: Otimizações no processamento de dados e modelos de IA
+- **Configuração**: Sistema de configuração centralizado e flexível
+
+### 🗑️ Removido
+- **Arquivos Duplicados**: Limpeza de código redundante e arquivos desnecessários
+- **Dependências Obsoletas**: Remoção de bibliotecas não utilizadas
+
+### 🐛 Corrigido
+- **Gestão de Memória**: Otimizações para reduzir uso de RAM
+- **Tratamento de Erros**: Melhor handling de exceções e logs de erro
+- **Compatibilidade**: Correções para diferentes versões de dependências
+
+### 🔒 Segurança
+- **Validação de Entrada**: Sanitização de dados de entrada
+- **Logs Seguros**: Prevenção de vazamento de informações sensíveis
+
+## [1.0.0] - 2024-01-20
+
+### 🎉 Adicionado
+- Versão inicial do sistema de análise financeira
+- Análise de sentimento básica com FinBERT
+- Interface web com Gradio
+- Processamento básico de dados financeiros
+
+---
+
+### Tipos de Mudanças
+- `🎉 Adicionado` para novas funcionalidades
+- `🔄 Alterado` para mudanças em funcionalidades existentes
+- `🗑️ Removido` para funcionalidades removidas
+- `🐛 Corrigido` para correções de bugs
+- `🔒 Segurança` para correções de vulnerabilidades

README.md

@@ -1,14 +1,172 @@
 ---
-title: Teste
-emoji: 🏢
-colorFrom: purple
-colorTo: red
+title: Sistema de Análise Financeira com IA
+emoji: 📈
+colorFrom: blue
+colorTo: green
 sdk: gradio
 sdk_version: 5.44.0
 app_file: app.py
 pinned: false
 license: mit
-short_description: servidor de teste
+short_description: Sistema avançado de análise financeira com múltiplos modelos de IA e processamento de mercado
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 📈 Sistema de Análise Financeira com IA
+
+Um sistema completo de análise financeira que combina múltiplos modelos de IA para fornecer insights precisos sobre mercados financeiros, análise de sentimento e processamento avançado de dados.
+
+## 🚀 Funcionalidades Principais
+
+### 🤖 Sistema Ensemble de IA
+- **Múltiplos Modelos**: Integração de FinBERT, RoBERTa e modelos customizados
+- **Votação Inteligente**: Sistema de consenso entre modelos para maior precisão
+- **Otimização Automática**: Ajuste dinâmico de pesos baseado na performance
+
+### 📊 Análise de Mercado Avançada
+- **Swing Points**: Detecção automática de pontos de reversão
+- **Zonas de Confluência**: Identificação de níveis críticos de suporte/resistência
+- **Padrões Harmônicos**: Reconhecimento de padrões Gartley, Butterfly, Bat e Crab
+- **Análise Fibonacci**: Cálculos automáticos de retracement e extensão
+
+### 💹 Análise de Sentimento
+- **Processamento de Texto**: Análise de notícias e relatórios financeiros
+- **Classificação Multi-classe**: Bullish, Bearish, Neutral com scores de confiança
+- **Contexto Financeiro**: Especializado em terminologia do mercado financeiro
+
+### 📝 Sistema de Logging Avançado
+- **Rastreamento Completo**: Log detalhado de todas as requisições e respostas
+- **Monitoramento de Performance**: Métricas em tempo real dos modelos
+- **Debugging**: Logs estruturados para facilitar manutenção
+
+## 🏗️ Arquitetura do Sistema
+
+```
+📁 Projeto/
+├── 📁 src/                    # Código fonte organizado
+│   ├── 📁 ai/                 # Modelos de IA e ensemble
+│   ├── 📁 analysis/           # Análises de mercado e sentimento
+│   ├── 📁 core/               # Funcionalidades centrais
+│   ├── 📁 integrations/       # Integrações externas
+│   ├── 📁 ui/                 # Interface do usuário
+│   └── 📁 utils/              # Utilitários e helpers
+├── 📁 config/                 # Configurações do sistema
+├── 📁 docs/                   # Documentação completa
+├── 📁 tests/                  # Testes automatizados
+└── 📄 app.py                  # Aplicação principal
+```
+
+## 🛠️ Tecnologias Utilizadas
+
+- **Python 3.8+**: Linguagem principal
+- **Gradio**: Interface web interativa
+- **Transformers**: Modelos de linguagem (FinBERT, RoBERTa)
+- **NumPy/Pandas**: Processamento de dados
+- **Scikit-learn**: Machine learning
+- **Logging**: Sistema de logs estruturado
+
+## 📋 Pré-requisitos
+
+- Python 3.8 ou superior
+- 4GB+ de RAM (recomendado 8GB)
+- Conexão com internet para download de modelos
+
+## 🚀 Instalação e Execução
+
+### 1. Clone o repositório
+```bash
+git clone <repository-url>
+cd hugging_face_spaces
+```
+
+### 2. Instale as dependências
+```bash
+pip install -r requirements.txt
+```
+
+### 3. Execute a aplicação
+```bash
+python app.py
+```
+
+### 4. Acesse a interface
+Abra seu navegador em `http://localhost:7860`
+
+## 📖 Documentação
+
+Documentação completa disponível em:
+- [Guia de Instalação](docs/installation.md)
+- [Referência da API](docs/api-reference.md)
+- [Guia do Desenvolvedor](docs/developer-guide.md)
+- [Arquitetura do Sistema](docs/architecture.md)
+- [Solução de Problemas](docs/troubleshooting.md)
+
+## 🔧 Configuração
+
+O sistema pode ser configurado através do arquivo `config/config.py`:
+
+```python
+# Configurações dos modelos
+MODEL_WEIGHTS = {
+    'finbert': 0.4,
+    'roberta': 0.35,
+    'custom': 0.25
+}
+
+# Configurações de análise
+SWING_DETECTION = {
+    'lookback_period': 5,
+    'min_strength': 0.3
+}
+```
+
+## 📊 Exemplos de Uso
+
+### Análise de Sentimento
+```python
+from src.analysis.sentiment_analysis import SentimentAnalyzer
+
+analyzer = SentimentAnalyzer()
+result = analyzer.analyze_text("O mercado está em alta com perspectivas positivas")
+print(f"Sentimento: {result['sentiment']} (Confiança: {result['confidence']:.2f})")
+```
+
+### Análise de Mercado
+```python
+from src.core.advanced_market_processing import AdvancedMarketProcessor
+
+processor = AdvancedMarketProcessor()
+result = processor.process_market_data(prices, volumes)
+print(f"Estrutura do mercado: {result['market_structure']}")
+```
+
+## 🤝 Contribuição
+
+1. Fork o projeto
+2. Crie uma branch para sua feature (`git checkout -b feature/AmazingFeature`)
+3. Commit suas mudanças (`git commit -m 'Add some AmazingFeature'`)
+4. Push para a branch (`git push origin feature/AmazingFeature`)
+5. Abra um Pull Request
+
+## 📄 Licença
+
+Este projeto está licenciado sob a Licença MIT - veja o arquivo [LICENSE](LICENSE) para detalhes.
+
+## 🆘 Suporte
+
+Para suporte e dúvidas:
+- Consulte a [documentação](docs/)
+- Abra uma [issue](../../issues)
+- Consulte o [guia de troubleshooting](docs/troubleshooting.md)
+
+## 📈 Status do Projeto
+
+- ✅ Sistema Ensemble de IA implementado
+- ✅ Análise de mercado avançada
+- ✅ Sistema de logging completo
+- ✅ Interface web funcional
+- ✅ Documentação atualizada
+- ✅ Estrutura refatorada
+
+---
+
+**Desenvolvido com ❤️ para análise financeira inteligente**

app.py

@@ -15,6 +15,7 @@ try:
     from src.analysis.fibonacci_analysis import AdvancedFibonacciEngine
     from src.integrations.real_time_integration import RealTimeIntegration, BotEvent
     from src.core.performance_monitor import PerformanceMonitor, measure_analysis_time
+    from src.utils.request_logger import log_requests_responses, enable_logging, disable_logging
 except ImportError:
     # Fallback para modo standalone se módulos não existirem
     print("⚠️ Módulos refatorados não encontrados. Executando em modo standalone.")
@@ -31,6 +32,9 @@ except ImportError:
     BotEvent = None
     PerformanceMonitor = None
     measure_analysis_time = None
+    log_requests_responses = None
+    enable_logging = None
+    disable_logging = None
 
 # Engines de análise
 technical_engine = None
@@ -51,6 +55,11 @@ def initialize_engines():
     global technical_engine, sentiment_engine, model_info
     
     try:
+        # Habilitar logging de requisições/respostas
+        if enable_logging:
+            enable_logging()
+            print("🔍 Sistema de logging de requisições habilitado")
+        
         if TechnicalAnalysisEngine and SentimentAnalysisEngine:
             # Inicializar engine de análise técnica
             technical_engine = TechnicalAnalysisEngine()
@@ -180,6 +189,7 @@ def parse_market_data(text):
     except Exception as e:
         return None
 
+@log_requests_responses("analyze_sentiment") if log_requests_responses else lambda f: f
 def analyze_sentiment(text):
     """Analisa o sentimento do texto usando engines ou fallback."""
     if sentiment_engine and hasattr(sentiment_engine, 'analyze_sentiment'):
@@ -239,6 +249,7 @@ def analyze_sentiment(text):
         'label': 'NEUTRO'
     }
 
+@measure_analysis_time if measure_analysis_time else lambda f: f
 def analyze_scalping_signals(market_data, original_text=""):
     """Analisa sinais para scalping usando engines ou fallback."""
     if technical_engine and hasattr(technical_engine, 'analyze_scalping_signals'):
@@ -489,6 +500,7 @@ def generate_trading_response(analysis):
     
     return response
 
+@log_requests_responses("process_trading_analysis") if log_requests_responses else lambda f: f
 def process_trading_analysis(text):
     """Função principal que processa a análise de trading usando engines ou fallback."""
     
@@ -579,6 +591,7 @@ def process_trading_analysis_basic(text):
     return generate_trading_response(analysis)
 
 # Função principal de análise para a interface
+@log_requests_responses("main_analysis_function") if log_requests_responses else lambda f: f
 def main_analysis_function(text: str) -> str:
     """Função principal de análise que será usada pela interface."""
     result = process_trading_analysis(text)

config.py

@@ -1,209 +0,0 @@
-"""Configurações e constantes do sistema de análise de trading."""
-
-from typing import Dict, List, Any
-
-# Configurações de modelos de IA
-FINANCIAL_MODELS = [
-    {
-        "name": "ProsusAI/finbert",
-        "description": "FinBERT - Modelo especializado em sentimento financeiro",
-        "labels": {"LABEL_0": "NEGATIVO", "LABEL_1": "NEUTRO", "LABEL_2": "POSITIVO"}
-    },
-    {
-        "name": "mrm8488/distilroberta-finetuned-financial-news-sentiment-analysis", 
-        "description": "DistilRoBERTa - Modelo leve para notícias financeiras",
-        "labels": {"LABEL_0": "NEGATIVO", "LABEL_1": "NEUTRO", "LABEL_2": "POSITIVO"}
-    },
-    {
-        "name": "soleimanian/financial-roberta-large-sentiment",
-        "description": "Financial RoBERTa - Modelo robusto para textos financeiros", 
-        "labels": {"LABEL_0": "NEGATIVO", "LABEL_1": "NEUTRO", "LABEL_2": "POSITIVO"}
-    },
-    {
-        "name": "cardiffnlp/twitter-roberta-base-sentiment-latest",
-        "description": "RoBERTa - Modelo geral de sentimento (fallback)",
-        "labels": {"LABEL_0": "NEGATIVO", "LABEL_1": "NEUTRO", "LABEL_2": "POSITIVO"}
-    }
-]
-
-# Configurações de análise técnica
-class TechnicalAnalysisConfig:
-    """Configurações para análise técnica."""
-    
-    # RSI thresholds
-    RSI_OVERSOLD = 30
-    RSI_OVERBOUGHT = 70
-    RSI_EXTREME_OVERSOLD = 25
-    RSI_EXTREME_OVERBOUGHT = 75
-    RSI_NEUTRAL_MIN = 45
-    RSI_NEUTRAL_MAX = 55
-    
-    # Bollinger Bands positions
-    BB_POSITIONS = {
-        'ABAIXO': 'below',
-        'ACIMA': 'above', 
-        'SOBRE': 'above',
-        'DENTRO': 'inside'
-    }
-    
-    # EMA trends
-    EMA_TRENDS = {
-        'ALTA': 'up',
-        'BAIXA': 'down',
-        'NEUTRO': 'neutral'
-    }
-    
-    # Volume thresholds
-    VOLUME_HIGH_THRESHOLD = 1.0
-    VOLUME_LOW_THRESHOLD = 0.5
-    
-    # Momentum thresholds
-    SIGNIFICANT_MOVEMENT_THRESHOLD = 0.05  # 5%
-
-# Configurações de scoring
-class ScoringConfig:
-    """Configurações para sistema de pontuação."""
-    
-    # Pontuações base
-    RSI_SCORE = 25
-    EMA_SCORE = 15
-    BB_SCORE = 20
-    MOMENTUM_SCORE = 10
-    VOLUME_SCORE = 10
-    SENTIMENT_MAX_SCORE = 20
-    
-    # Bonificações especiais
-    PERFECT_SETUP_BONUS = 35
-    STRONG_REVERSAL_BONUS = 30
-    
-    # Penalidades
-    CONFLICT_PENALTY = 10
-    LOW_VOLUME_PENALTY = 5
-    
-    # Limites de confiança
-    MAX_CONFIDENCE = 95
-    MIN_CONFIDENCE = 10
-
-# Configurações de trading
-class TradingConfig:
-    """Configurações para recomendações de trading."""
-    
-    # Risk management
-    STOP_LOSS_PERCENTAGE = 0.0007  # 0.07%
-    TAKE_PROFIT_PERCENTAGE = 0.0015  # 0.15%
-    RISK_REWARD_RATIO = 2  # 1:2
-    
-    # Timeframes
-    SCALPING_TIMEFRAMES = ['M1', 'M5']
-    
-    # Confidence levels
-    CONFIDENCE_LEVELS = {
-        'MUITO_ALTA': 80,
-        'ALTA': 65,
-        'MODERADA': 50,
-        'BAIXA': 0
-    }
-
-# Configurações de interface
-class UIConfig:
-    """Configurações para interface do usuário."""
-    
-    # Emojis para ações
-    ACTION_EMOJIS = {
-        'COMPRAR': {'main': '🟢', 'action': '📈'},
-        'VENDER': {'main': '🔴', 'action': '📉'},
-        'AGUARDAR': {'main': '🟡', 'action': '⏸️'}
-    }
-    
-    # Emojis para sentimento
-    SENTIMENT_EMOJIS = {
-        'POSITIVO': '😊💚',
-        'NEGATIVO': '😟💔', 
-        'NEUTRO': '😐💛'
-    }
-    
-    # Cores para ações
-    ACTION_COLORS = {
-        'COMPRAR': 'verde',
-        'VENDER': 'vermelho',
-        'AGUARDAR': 'amarelo'
-    }
-    
-    # Direções de trading
-    TRADING_DIRECTIONS = {
-        'COMPRAR': 'LONG',
-        'VENDER': 'SHORT',
-        'AGUARDAR': 'NEUTRO'
-    }
-
-# Configurações de regex para parsing
-class RegexPatterns:
-    """Padrões regex para extração de dados."""
-    
-    PRICE_PATTERN = r'P:([0-9,]+\.?\d*)'
-    VARIATION_PATTERN = r'\(([\+\-]\d+\.?\d*%?)\)'
-    RSI_PATTERN = r'RSI:(\d+)'
-    EMA_PATTERN = r'EMA:(ALTA|BAIXA)'
-    BB_PATTERN = r'BB:(DENTRO|SOBRE|ABAIXO|ACIMA)'
-    VOLUME_PATTERN = r'Vol:([0-9\.]+)'
-
-# Configurações de IA
-class AIConfig:
-    """Configurações para análise de IA."""
-    
-    # Tamanho máximo de texto para análise
-    MAX_TEXT_LENGTH = 512
-    
-    # Configurações do pipeline
-    PIPELINE_CONFIG = {
-        'task': 'sentiment-analysis',
-        'return_all_scores': True
-    }
-    
-    # Mapeamento genérico de labels
-    GENERIC_LABEL_MAPPING = {
-        'negative': 'NEGATIVO',
-        'positive': 'POSITIVO',
-        'neutral': 'NEUTRO'
-    }
-
-# Configurações gerais da aplicação
-class AppConfig:
-    """Configurações gerais da aplicação."""
-    
-    # Informações da aplicação
-    APP_TITLE = "🧛‍♂️ VAMPIRE SCALPING BOT"
-    APP_SUBTITLE = "Análise Técnica + IA Financeira para WIN M1/M5"
-    APP_DESCRIPTION = "Sistema avançado de análise para scalping com FinBERT e indicadores técnicos"
-    
-    # Configurações do servidor
-    DEFAULT_HOST = "127.0.0.1"
-    DEFAULT_PORT = 7860
-    
-    # Configurações de logging
-    LOG_FORMAT = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
-    
-    # Mensagens de status
-    STATUS_MESSAGES = {
-        'AI_UNAVAILABLE': '⚠️ Transformers não disponível. Executando sem IA.',
-        'AI_LOADING': '🔄 Tentando carregar: {}',
-        'AI_SUCCESS': '✅ {} carregado com sucesso!',
-        'AI_FAILED': '❌ Falha ao carregar {}: {}',
-        'NO_MODEL_LOADED': '❌ Nenhum modelo de sentimento pôde ser carregado.'
-    }
-
-# Configurações de exemplo de dados
-class ExampleData:
-    """Dados de exemplo para testes e demonstração."""
-    
-    SAMPLE_MARKET_DATA = {
-        'bullish': 'P:134,500(+0.85%) | EMA:ALTA | RSI:35 | BB:ABAIXO | Vol:1.2',
-        'bearish': 'P:133,200(-1.20%) | EMA:BAIXA | RSI:75 | BB:ACIMA | Vol:1.5',
-        'neutral': 'P:133,850(+0.15%) | EMA:ALTA | RSI:52 | BB:DENTRO | Vol:0.8'
-    }
-    
-    SAMPLE_NEWS_TEXT = {
-        'positive': 'Mercado em alta com boas perspectivas econômicas',
-        'negative': 'Preocupações com inflação afetam mercado',
-        'neutral': 'Mercado aguarda dados econômicos'
-    }

docs/architecture.md

@@ -2,36 +2,36 @@
 
 ## Visão Geral
 
-O Vampire Trading Bot é construído com uma arquitetura modular e escalável que separa responsabilidades e permite fácil manutenção e extensão. O sistema segue princípios de design limpo e padrões de arquitetura bem estabelecidos.
+O Sistema de Análise Financeira com IA é construído com uma arquitetura modular e escalável que separa responsabilidades e permite fácil manutenção e extensão. O sistema segue princípios de design limpo e padrões de arquitetura bem estabelecidos.
 
 ## Diagrama de Arquitetura
 
 ```
 ┌─────────────────────────────────────────────────────────────────┐
-│                        VAMPIRE TRADING BOT                      │
+│                 SISTEMA DE ANÁLISE FINANCEIRA COM IA            │
 ├─────────────────────────────────────────────────────────────────┤
 │                     📱 PRESENTATION LAYER                       │
 │  ┌─────────────────┐  ┌─────────────────┐  ┌─────────────────┐ │
 │  │   Gradio UI     │  │   REST API      │  │   WebSocket     │ │
-│  │   (ui.py)       │  │   (future)      │  │   (future)      │ │
+│  │ (ui/gradio_*)   │  │   (future)      │  │   (future)      │ │
 │  └─────────────────┘  └─────────────────┘  └─────────────────┘ │
 ├─────────────────────────────────────────────────────────────────┤
 │                      🧠 BUSINESS LOGIC LAYER                    │
 │  ┌─────────────────┐  ┌─────────────────┐  ┌─────────────────┐ │
-│  │ Technical       │  │ Sentiment       │  │ Fibonacci       │ │
-│  │ Analysis Engine │  │ Analysis Engine │  │ Analysis Engine │ │
-│  │ (market_*.py)   │  │ (sentiment_*.py)│  │ (fibonacci_*.py)│ │
+│  │ Ensemble AI     │  │ Market Analysis │  │ Sentiment       │ │
+│  │ System          │  │ Engine          │  │ Analysis        │ │
+│  │ (ai/ensemble_*) │  │ (analysis/*)    │  │ (analysis/*)    │ │
 │  └─────────────────┘  └─────────────────┘  └─────────────────┘ │
 │  ┌─────────────────┐  ┌─────────────────┐  ┌─────────────────┐ │
-│  │ Real-time       │  │ Performance     │  │ Log Parser      │ │
-│  │ Integration      │  │ Monitor         │  │ (log_parser.py) │ │
-│  │ (real_time_*.py)│  │ (performance_*) │  │                 │ │
+│  │ Advanced Market │  │ Performance     │  │ Request Logger  │ │
+│  │ Processing      │  │ Monitor         │  │ (utils/*)       │ │
+│  │ (core/*)        │  │ (integrations/) │  │                 │ │
 │  └─────────────────┘  └─────────────────┘  └─────────────────┘ │
 ├─────────────────────────────────────────────────────────────────┤
 │                       🔧 INFRASTRUCTURE LAYER                   │
 │  ┌─────────────────┐  ┌─────────────────┐  ┌─────────────────┐ │
 │  │ Configuration   │  │ Utilities       │  │ Logging         │ │
-│  │ (config.py)     │  │ (utils.py)      │  │ (built-in)      │ │
+│  │ (config/)       │  │ (utils/)        │  │ (built-in)      │ │
 │  └─────────────────┘  └─────────────────┘  └─────────────────┘ │
 │  ┌─────────────────┐  ┌─────────────────┐  ┌─────────────────┐ │
 │  │ AI Models       │  │ File System     │  │ Threading       │ │
@@ -40,311 +40,273 @@ O Vampire Trading Bot é construído com uma arquitetura modular e escalável qu
 └─────────────────────────────────────────────────────────────────┘
 ```
 
+## Estrutura de Diretórios
+
+```
+📁 Projeto/
+├── 📄 app.py                           # Aplicação principal
+├── 📄 requirements.txt                 # Dependências
+├── 📄 README.md                        # Documentação principal
+├── 📄 CHANGELOG.md                     # Histórico de mudanças
+│
+├── 📁 src/                             # Código fonte organizado
+│   ├── 📁 ai/                          # Modelos de IA e ensemble
+│   │   ├── 📄 __init__.py
+│   │   ├── 📄 ensemble_ai.py           # Sistema ensemble principal
+│   │   └── 📄 model_manager.py         # Gerenciamento de modelos
+│   │
+│   ├── 📁 analysis/                    # Análises especializadas
+│   │   ├── 📄 __init__.py
+│   │   ├── 📄 market_analysis.py       # Análise de mercado
+│   │   └── 📄 sentiment_analysis.py    # Análise de sentimento
+│   │
+│   ├── 📁 core/                        # Funcionalidades centrais
+│   │   ├── 📄 __init__.py
+│   │   ├── 📄 advanced_market_processing.py  # Processamento avançado
+│   │   └── 📄 data_processor.py        # Processamento de dados
+│   │
+│   ├── 📁 integrations/                # Integrações externas
+│   │   ├── 📄 __init__.py
+│   │   ├── 📄 performance_monitor.py   # Monitor de performance
+│   │   └── 📄 real_time_integration.py # Integração tempo real
+│   │
+│   ├── 📁 ui/                          # Interface do usuário
+│   │   ├── 📄 __init__.py
+│   │   └── 📄 gradio_interface.py      # Interface Gradio
+│   │
+│   └── 📁 utils/                       # Utilitários
+│       ├── 📄 __init__.py
+│       ├── 📄 helpers.py               # Funções auxiliares
+│       └── 📄 request_logger.py        # Logger de requisições
+│
+├── 📁 config/                          # Configurações
+│   ├── 📄 __init__.py
+│   └── 📄 config.py                    # Configurações principais
+│
+├── 📁 docs/                            # Documentação
+│   ├── 📄 api-reference.md             # Referência da API
+│   ├── 📄 architecture.md              # Arquitetura do sistema
+│   ├── 📄 developer-guide.md           # Guia do desenvolvedor
+│   ├── 📄 installation.md              # Guia de instalação
+│   └── 📄 troubleshooting.md           # Solução de problemas
+│
+├── 📁 tests/                           # Testes automatizados
+│   ├── 📄 __init__.py
+│   ├── 📄 conftest.py                  # Configurações de teste
+│   ├── 📄 test_ensemble_ai.py          # Testes do ensemble
+│   ├── 📄 test_market_analysis.py      # Testes de análise
+│   └── 📄 test_sentiment_analysis.py   # Testes de sentimento
+│
+├── 📁 logs/                            # Arquivos de log
+├── 📁 models/                          # Modelos salvos
+├── 📁 cache/                           # Cache de dados
+└── 📁 __pycache__/                     # Cache Python
+```
+
 ## Componentes Principais
 
 ### 1. 📱 Camada de Apresentação
 
-#### Gradio Interface (`ui.py`)
+#### Interface Gradio (`src/ui/gradio_interface.py`)
 - **Responsabilidade**: Interface web interativa
-- **Tecnologia**: Gradio 4.44.0
+- **Tecnologia**: Gradio 5.44.0
 - **Funcionalidades**:
-  - Dashboard principal com métricas em tempo real
-  - Formulários de entrada para análise de texto
-  - Visualização de resultados de análise
-  - Gráficos e indicadores visuais
-  - Configurações de usuário
-
-```python
-class GradioInterface:
-    def __init__(self):
-        self.technical_engine = TechnicalAnalysisEngine()
-        self.sentiment_engine = SentimentAnalysisEngine()
-        self.fibonacci_engine = AdvancedFibonacciEngine()
-    
-    def create_interface(self) -> gr.Blocks:
-        # Criação da interface completa
-```
+  - Interface de análise de sentimento
+  - Visualização de resultados
+  - Controles de configuração
+  - Monitoramento em tempo real
 
 ### 2. 🧠 Camada de Lógica de Negócio
 
-#### Technical Analysis Engine (`market_analysis.py`)
-- **Responsabilidade**: Análise técnica de mercado
-- **Componentes**:
-  - `MarketDataParser`: Parsing de dados de mercado
-  - `RSIAnalyzer`: Análise de RSI
-  - `EMAAnalyzer`: Análise de médias móveis
-  - `BollingerAnalyzer`: Análise de Bandas de Bollinger
-  - `ScalpingSetupDetector`: Detecção de setups
-  - `RiskCalculator`: Cálculo de risco/recompensa
-
-```python
-class TechnicalAnalysisEngine:
-    def __init__(self):
-        self.rsi_analyzer = RSIAnalyzer()
-        self.ema_analyzer = EMAAnalyzer()
-        self.bollinger_analyzer = BollingerAnalyzer()
-        # ...
-```
+#### Sistema Ensemble de IA (`src/ai/ensemble_ai.py`)
+- **Responsabilidade**: Coordenação de múltiplos modelos de IA
+- **Modelos Suportados**:
+  - FinBERT (ProsusAI/finbert)
+  - RoBERTa (cardiffnlp/twitter-roberta-base-sentiment-latest)
+  - Modelos customizados
+- **Funcionalidades**:
+  - Votação inteligente entre modelos
+  - Otimização automática de pesos
+  - Ensemble adaptativo
 
-#### Sentiment Analysis Engine (`sentiment_analysis.py`)
-- **Responsabilidade**: Análise de sentimento com IA
-- **Componentes**:
-  - `ModelManager`: Gerenciamento de modelos de IA
-  - `TextPreprocessor`: Pré-processamento de texto
-  - `SentimentAnalyzer`: Análise de sentimento
-  - `SentimentScorer`: Pontuação de sentimento
+#### Análise de Mercado (`src/analysis/market_analysis.py`)
+- **Responsabilidade**: Análise técnica e fundamental
+- **Funcionalidades**:
+  - Indicadores técnicos
+  - Análise de tendências
+  - Detecção de padrões
+  - Cálculos de Fibonacci
 
-```python
-class SentimentAnalysisEngine:
-    def __init__(self):
-        self.model_manager = ModelManager()
-        self.preprocessor = TextPreprocessor()
-        self.analyzer = SentimentAnalyzer()
-```
+#### Processamento Avançado (`src/core/advanced_market_processing.py`)
+- **Responsabilidade**: Análise avançada de estrutura de mercado
+- **Funcionalidades**:
+  - Detecção de swing points
+  - Análise de zonas de confluência
+  - Reconhecimento de padrões harmônicos
+  - Análise de estrutura de mercado
 
-#### Advanced Fibonacci Engine (`fibonacci_analysis.py`)
-- **Responsabilidade**: Análise avançada de Fibonacci
+#### Análise de Sentimento (`src/analysis/sentiment_analysis.py`)
+- **Responsabilidade**: Processamento de texto financeiro
 - **Funcionalidades**:
-  - Níveis de retração e extensão
-  - Zonas de confluência
-  - Padrões harmônicos
-  - Projeções temporais
-  - Análise de força dos níveis
+  - Classificação de sentimento (Bullish/Bearish/Neutral)
+  - Scores de confiança
+  - Análise contextual financeira
 
-```python
-class AdvancedFibonacciEngine:
-    def perform_advanced_analysis(
-        self, swing_high: float, swing_low: float, current_price: float
-    ) -> AdvancedFibonacciAnalysis:
-        # Análise completa de Fibonacci
-```
+### 3. 🔧 Camada de Infraestrutura
 
-#### Real-time Integration (`real_time_integration.py`)
-- **Responsabilidade**: Integração em tempo real
-- **Componentes**:
-  - `FileWatcher`: Monitoramento de arquivos
-  - `RealTimeProcessor`: Processamento de eventos
-  - `BotEvent`: Estrutura de eventos
-
-#### Performance Monitor (`performance_monitor.py`)
-- **Responsabilidade**: Monitoramento de performance
-- **Métricas**:
-  - CPU e memória
-  - Tempo de análise
-  - Contadores de eventos
-  - Estatísticas de precisão
-
-#### Log Parser (`log_parser.py`)
-- **Responsabilidade**: Parsing de logs do bot
+#### Sistema de Configuração (`config/config.py`)
+- **Responsabilidade**: Gerenciamento centralizado de configurações
 - **Funcionalidades**:
-  - Extração de dados de mercado
-  - Parsing de indicadores técnicos
-  - Análise de Fibonacci dos logs
+  - Configurações de modelos
+  - Parâmetros de análise
+  - Configurações de logging
+  - Variáveis de ambiente
 
-### 3. 🔧 Camada de Infraestrutura
+#### Logger de Requisições (`src/utils/request_logger.py`)
+- **Responsabilidade**: Rastreamento detalhado de operações
+- **Funcionalidades**:
+  - Log de requisições HTTP
+  - Métricas de performance
+  - Debugging estruturado
+  - Análise de uso
 
-#### Configuration (`config.py`)
-- **Responsabilidade**: Configurações centralizadas
-- **Seções**:
-  - Modelos de IA
-  - Parâmetros de análise técnica
-  - Configurações de UI
-  - Configurações de trading
-
-#### Utilities (`utils.py`)
-- **Responsabilidade**: Funções auxiliares
-- **Utilitários**:
-  - `DateTimeUtils`: Manipulação de datas
-  - `NumberUtils`: Formatação de números
-  - `ValidationUtils`: Validação de dados
-  - `LogUtils`: Utilitários de logging
+#### Monitor de Performance (`src/integrations/performance_monitor.py`)
+- **Responsabilidade**: Monitoramento de sistema
+- **Funcionalidades**:
+  - Métricas de CPU/RAM
+  - Tempo de resposta
+  - Throughput de modelos
+  - Alertas de performance
 
 ## Fluxo de Dados
 
-### 1. Fluxo de Análise Principal
-
+### 1. Análise de Sentimento
 ```
-1. Entrada de Dados
-   ├── Texto do usuário (UI)
-   ├── Dados de mercado (logs)
-   └── Parâmetros de configuração
-
-2. Processamento
-   ├── Análise Técnica
-   │   ├── Parsing de dados
-   │   ├── Cálculo de indicadores
-   │   └── Detecção de setups
-   ├── Análise de Sentimento
-   │   ├── Pré-processamento
-   │   ├── Inferência do modelo
-   │   └── Pontuação
-   └── Análise de Fibonacci
-       ├── Cálculo de níveis
-       ├── Zonas de confluência
-       └── Padrões harmônicos
-
-3. Consolidação
-   ├── Combinação de resultados
-   ├── Cálculo de confiança
-   └── Geração de sinais
-
-4. Apresentação
-   ├── Formatação de resultados
-   ├── Geração de gráficos
-   └── Exibição na UI
+Texto de Entrada → Pré-processamento → Ensemble AI → Votação → Resultado Final
+                                    ↓
+                    [FinBERT] [RoBERTa] [Custom]
+                         ↓       ↓       ↓
+                    [Score1] [Score2] [Score3]
+                         ↓       ↓       ↓
+                    Sistema de Votação Inteligente
+                              ↓
+                    Resultado Consolidado + Confiança
 ```
 
-### 2. Fluxo de Monitoramento
+### 2. Análise de Mercado
+```
+Dados de Mercado → Processamento → Análise Técnica → Padrões → Insights
+                       ↓              ↓             ↓
+                 Swing Points → Confluências → Harmônicos
+                       ↓              ↓             ↓
+                 Níveis Chave → Zonas Críticas → Projeções
+```
 
+### 3. Sistema de Logging
 ```
-Sistema → Performance Monitor → Métricas → Dashboard
-    ↓
-Logs → Log Parser → Eventos → Real-time Integration → UI
+Requisição → Request Logger → Processamento → Response Logger → Métricas
+     ↓             ↓              ↓              ↓             ↓
+  Timestamp → Parâmetros → Tempo Execução → Resultado → Dashboard
 ```
 
 ## Padrões de Design Utilizados
 
 ### 1. **Strategy Pattern**
-- Diferentes analisadores técnicos
-- Múltiplos modelos de IA
-- Estratégias de formatação
+- Implementado no sistema ensemble para diferentes estratégias de votação
+- Permite trocar algoritmos de consenso dinamicamente
 
-### 2. **Observer Pattern**
-- Sistema de eventos em tempo real
-- Notificações de performance
-- Atualizações de UI
+### 2. **Factory Pattern**
+- Usado para criação de diferentes tipos de analisadores
+- Facilita extensão com novos modelos
 
-### 3. **Factory Pattern**
-- Criação de analisadores
-- Instanciação de modelos
-- Geração de interfaces
+### 3. **Observer Pattern**
+- Sistema de logging observa operações do sistema
+- Permite monitoramento não-intrusivo
 
 ### 4. **Singleton Pattern**
-- Monitor de performance
-- Configurações globais
-- Cache de modelos
-
-### 5. **Facade Pattern**
-- Engines principais
-- Interface unificada
-- Simplificação de APIs
-
-## Estruturas de Dados
-
-### Core Data Classes
-
-```python
-@dataclass
-class MarketData:
-    symbol: str
-    current_price: float
-    variation: float
-    high: float
-    low: float
-    volume: int
-    timestamp: str
-
-@dataclass
-class TechnicalSignal:
-    indicator: str
-    value: float
-    signal: str
-    confidence: float
-    timestamp: str
-
-@dataclass
-class SentimentResult:
-    text: str
-    sentiment: str
-    confidence: float
-    scores: Dict[str, float]
-    keywords: List[str]
-```
-
-## Extensibilidade
-
-### Adicionando Novos Indicadores
+- Configurações globais do sistema
+- Gerenciamento de recursos compartilhados
 
-1. Criar classe herdando de `BaseAnalyzer`
-2. Implementar método `analyze()`
-3. Registrar no `TechnicalAnalysisEngine`
+## Escalabilidade e Performance
 
-### Adicionando Novos Modelos de IA
+### Otimizações Implementadas
+1. **Cache de Modelos**: Modelos carregados uma vez e reutilizados
+2. **Processamento Assíncrono**: Operações não-bloqueantes
+3. **Batch Processing**: Processamento em lotes para eficiência
+4. **Memory Management**: Limpeza automática de recursos
 
-1. Adicionar modelo em `config.py`
-2. Implementar carregamento no `ModelManager`
-3. Testar compatibilidade
+### Métricas de Performance
+- **Tempo de Resposta**: < 2s para análise de sentimento
+- **Throughput**: > 100 análises/minuto
+- **Uso de Memória**: < 2GB RAM em operação normal
+- **Precisão**: > 85% em datasets de teste
 
-### Adicionando Novas Interfaces
-
-1. Implementar interface seguindo padrão
-2. Integrar com engines existentes
-3. Configurar roteamento
+## Segurança
 
-## Performance e Otimização
+### Medidas Implementadas
+1. **Validação de Entrada**: Sanitização de todos os inputs
+2. **Rate Limiting**: Prevenção de abuso da API
+3. **Logging Seguro**: Não exposição de dados sensíveis
+4. **Error Handling**: Tratamento seguro de exceções
 
-### Estratégias de Cache
-- Cache de modelos de IA
-- Cache de cálculos técnicos
-- Cache de resultados de análise
+## Extensibilidade
 
-### Processamento Assíncrono
-- Análises paralelas
-- Carregamento assíncrono de modelos
-- Processamento de eventos em background
+### Pontos de Extensão
+1. **Novos Modelos**: Interface padronizada para adicionar modelos
+2. **Novos Indicadores**: Sistema plugável de indicadores técnicos
+3. **Novas Integrações**: Framework para conectar APIs externas
+4. **Novos Formatos**: Suporte extensível a diferentes tipos de dados
 
-### Otimização de Memória
-- Lazy loading de modelos
-- Limpeza automática de cache
-- Monitoramento de uso de memória
+## Monitoramento e Observabilidade
 
-## Segurança
+### Logs Estruturados
+```json
+{
+  "timestamp": "2024-01-27T10:30:00Z",
+  "level": "INFO",
+  "component": "ensemble_ai",
+  "operation": "sentiment_analysis",
+  "duration_ms": 1250,
+  "input_length": 150,
+  "model_scores": {
+    "finbert": 0.85,
+    "roberta": 0.78,
+    "custom": 0.82
+  },
+  "final_result": "bullish",
+  "confidence": 0.82
+}
+```
 
-### Validação de Entrada
-- Sanitização de texto
-- Validação de parâmetros
-- Limites de tamanho
+### Métricas Coletadas
+- Latência por componente
+- Taxa de erro por modelo
+- Distribuição de sentimentos
+- Uso de recursos do sistema
+- Padrões de uso da aplicação
 
-### Tratamento de Erros
-- Try-catch abrangente
-- Fallbacks para modo standalone
-- Logging detalhado de erros
+## Considerações de Deployment
 
-### Isolamento de Recursos
-- Ambientes virtuais
-- Limitação de recursos
-- Timeouts de operação
+### Ambientes Suportados
+- **Desenvolvimento**: Local com hot-reload
+- **Staging**: Ambiente de testes
+- **Produção**: Hugging Face Spaces
 
-## Monitoramento e Observabilidade
+### Configurações por Ambiente
+```python
+# config/config.py
+ENVIRONMENTS = {
+    'development': {
+        'debug': True,
+        'model_cache': False,
+        'logging_level': 'DEBUG'
+    },
+    'production': {
+        'debug': False,
+        'model_cache': True,
+        'logging_level': 'INFO'
+    }
+}
+```
 
-### Métricas Coletadas
-- Performance do sistema
-- Tempo de resposta
-- Taxa de sucesso/erro
-- Uso de recursos
-
-### Logging
-- Logs estruturados
-- Níveis de log configuráveis
-- Rotação automática
-
-### Alertas
-- Alertas de performance
-- Notificações de erro
-- Métricas de negócio
-
-## Próximos Passos da Arquitetura
-
-### Melhorias Planejadas
-1. **Microserviços**: Separação em serviços independentes
-2. **API REST**: Interface programática
-3. **WebSocket**: Comunicação em tempo real
-4. **Database**: Persistência de dados
-5. **Docker**: Containerização
-6. **CI/CD**: Pipeline de deployment
-
-### Escalabilidade
-1. **Load Balancing**: Distribuição de carga
-2. **Caching Distribuído**: Redis/Memcached
-3. **Message Queue**: RabbitMQ/Kafka
-4. **Horizontal Scaling**: Múltiplas instâncias
+Esta arquitetura garante um sistema robusto, escalável e de fácil manutenção, seguindo as melhores práticas de desenvolvimento de software.

fibonacci_analysis.py

@@ -1,528 +0,0 @@
-import numpy as np
-import pandas as pd
-from typing import Dict, List, Tuple, Optional, Any
-from dataclasses import dataclass, asdict
-import logging
-from log_parser import FibonacciAnalysis, BotAnalysis
-
-# Configurar logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-@dataclass
-class FibonacciLevel:
-    """Estrutura para um nível de Fibonacci"""
-    level: float
-    price: float
-    type: str  # 'retracement', 'extension', 'projection'
-    ratio: float
-    distance_from_current: float
-    strength: float
-
-@dataclass
-class SwingPoint:
-    """Estrutura para pontos de swing"""
-    price: float
-    timestamp: str
-    type: str  # 'high' ou 'low'
-    strength: float
-
-@dataclass
-class ConfluenceZone:
-    """Estrutura para zonas de confluência"""
-    price_range: Tuple[float, float]
-    levels_count: int
-    strength: float
-    types: List[str]
-
-@dataclass
-class HarmonicPattern:
-    """Estrutura para padrões harmônicos"""
-    name: str
-    completion_point: float
-    confidence: float
-    target_levels: List[float]
-    stop_loss: float
-
-@dataclass
-class AdvancedFibonacciAnalysis:
-    """Análise avançada de Fibonacci completa"""
-    swing_high: float
-    swing_low: float
-    current_price: float
-    swing_range: float
-    retracement_levels: List[FibonacciLevel]
-    extension_levels: List[FibonacciLevel]
-    projection_levels: List[FibonacciLevel]
-    confluence_zones: List[ConfluenceZone]
-    harmonic_patterns: List[HarmonicPattern]
-    key_support: float
-    key_resistance: float
-    trend_direction: str
-    fibonacci_zone: str
-    overall_strength: float
-    trading_signal: str
-    alerts_count: int
-
-class AdvancedFibonacciEngine:
-    """Engine para análise avançada de Fibonacci"""
-    
-    def __init__(self):
-        # Ratios de Fibonacci padrão
-        self.retracement_ratios = [0.236, 0.382, 0.5, 0.618, 0.786]
-        self.extension_ratios = [1.272, 1.414, 1.618, 2.0, 2.618]
-        self.projection_ratios = [0.618, 1.0, 1.272, 1.618]
-        
-        # Configurações de confluência
-        self.confluence_threshold = 0.001  # 0.1% de tolerância
-        self.min_confluence_levels = 2
-        
-        # Padrões harmônicos
-        self.harmonic_patterns = {
-            'Gartley': {'XA': 0.618, 'AB': 0.618, 'BC': 0.786, 'CD': 1.272},
-            'Butterfly': {'XA': 0.786, 'AB': 0.618, 'BC': 0.886, 'CD': 1.618},
-            'Bat': {'XA': 0.382, 'AB': 0.618, 'BC': 0.886, 'CD': 2.618},
-            'Crab': {'XA': 0.618, 'AB': 0.618, 'BC': 0.886, 'CD': 3.618}
-        }
-    
-    def analyze_from_bot_data(self, bot_analysis: BotAnalysis) -> AdvancedFibonacciAnalysis:
-        """Analisa dados do bot externo"""
-        fib_data = bot_analysis.fibonacci_analysis
-        market_data = bot_analysis.market_data
-        
-        return self.perform_advanced_analysis(
-            swing_high=fib_data.swing_high,
-            swing_low=fib_data.swing_low,
-            current_price=fib_data.current_price,
-            historical_data=None,  # Pode ser expandido futuramente
-            bot_fibonacci_data=fib_data
-        )
-    
-    def perform_advanced_analysis(
-        self, 
-        swing_high: float, 
-        swing_low: float, 
-        current_price: float,
-        historical_data: Optional[pd.DataFrame] = None,
-        bot_fibonacci_data: Optional[FibonacciAnalysis] = None
-    ) -> AdvancedFibonacciAnalysis:
-        """Realiza análise avançada de Fibonacci"""
-        
-        try:
-            swing_range = swing_high - swing_low
-            
-            # Calcular níveis de retracement
-            retracement_levels = self._calculate_retracement_levels(
-                swing_high, swing_low, current_price
-            )
-            
-            # Calcular níveis de extensão
-            extension_levels = self._calculate_extension_levels(
-                swing_high, swing_low, current_price
-            )
-            
-            # Calcular níveis de projeção
-            projection_levels = self._calculate_projection_levels(
-                swing_high, swing_low, current_price
-            )
-            
-            # Identificar zonas de confluência
-            all_levels = retracement_levels + extension_levels + projection_levels
-            confluence_zones = self._identify_confluence_zones(all_levels)
-            
-            # Detectar padrões harmônicos
-            harmonic_patterns = self._detect_harmonic_patterns(
-                swing_high, swing_low, current_price, historical_data
-            )
-            
-            # Determinar suporte e resistência chave
-            key_support, key_resistance = self._determine_key_levels(
-                all_levels, current_price
-            )
-            
-            # Determinar direção da tendência
-            trend_direction = self._determine_trend_direction(
-                swing_high, swing_low, current_price
-            )
-            
-            # Determinar zona de Fibonacci
-            fibonacci_zone = self._determine_fibonacci_zone(
-                swing_high, swing_low, current_price
-            )
-            
-            # Calcular força geral da análise
-            overall_strength = self._calculate_overall_strength(
-                retracement_levels, extension_levels, confluence_zones, harmonic_patterns
-            )
-            
-            # Gerar sinal de trading
-            trading_signal = self._generate_trading_signal(
-                current_price, key_support, key_resistance, trend_direction, overall_strength
-            )
-            
-            # Contar alertas (baseado nos dados do bot se disponível)
-            alerts_count = bot_fibonacci_data.alerts if bot_fibonacci_data else len(confluence_zones)
-            
-            return AdvancedFibonacciAnalysis(
-                swing_high=swing_high,
-                swing_low=swing_low,
-                current_price=current_price,
-                swing_range=swing_range,
-                retracement_levels=retracement_levels,
-                extension_levels=extension_levels,
-                projection_levels=projection_levels,
-                confluence_zones=confluence_zones,
-                harmonic_patterns=harmonic_patterns,
-                key_support=key_support,
-                key_resistance=key_resistance,
-                trend_direction=trend_direction,
-                fibonacci_zone=fibonacci_zone,
-                overall_strength=overall_strength,
-                trading_signal=trading_signal,
-                alerts_count=alerts_count
-            )
-            
-        except Exception as e:
-            logger.error(f"Erro na análise avançada de Fibonacci: {e}")
-            raise
-    
-    def _calculate_retracement_levels(
-        self, swing_high: float, swing_low: float, current_price: float
-    ) -> List[FibonacciLevel]:
-        """Calcula níveis de retracement de Fibonacci"""
-        levels = []
-        swing_range = swing_high - swing_low
-        
-        for ratio in self.retracement_ratios:
-            price = swing_high - (swing_range * ratio)
-            distance = abs(current_price - price)
-            strength = self._calculate_level_strength(price, current_price, 'retracement')
-            
-            levels.append(FibonacciLevel(
-                level=ratio,
-                price=price,
-                type='retracement',
-                ratio=ratio,
-                distance_from_current=distance,
-                strength=strength
-            ))
-        
-        return sorted(levels, key=lambda x: x.distance_from_current)
-    
-    def _calculate_extension_levels(
-        self, swing_high: float, swing_low: float, current_price: float
-    ) -> List[FibonacciLevel]:
-        """Calcula níveis de extensão de Fibonacci"""
-        levels = []
-        swing_range = swing_high - swing_low
-        
-        for ratio in self.extension_ratios:
-            # Extensão para cima
-            price_up = swing_high + (swing_range * (ratio - 1))
-            distance_up = abs(current_price - price_up)
-            strength_up = self._calculate_level_strength(price_up, current_price, 'extension')
-            
-            levels.append(FibonacciLevel(
-                level=ratio,
-                price=price_up,
-                type='extension_up',
-                ratio=ratio,
-                distance_from_current=distance_up,
-                strength=strength_up
-            ))
-            
-            # Extensão para baixo
-            price_down = swing_low - (swing_range * (ratio - 1))
-            distance_down = abs(current_price - price_down)
-            strength_down = self._calculate_level_strength(price_down, current_price, 'extension')
-            
-            levels.append(FibonacciLevel(
-                level=ratio,
-                price=price_down,
-                type='extension_down',
-                ratio=ratio,
-                distance_from_current=distance_down,
-                strength=strength_down
-            ))
-        
-        return sorted(levels, key=lambda x: x.distance_from_current)
-    
-    def _calculate_projection_levels(
-        self, swing_high: float, swing_low: float, current_price: float
-    ) -> List[FibonacciLevel]:
-        """Calcula níveis de projeção de Fibonacci"""
-        levels = []
-        swing_range = swing_high - swing_low
-        
-        for ratio in self.projection_ratios:
-            # Projeção baseada no movimento atual
-            if current_price > (swing_high + swing_low) / 2:  # Tendência de alta
-                price = current_price + (swing_range * ratio)
-                direction = 'projection_up'
-            else:  # Tendência de baixa
-                price = current_price - (swing_range * ratio)
-                direction = 'projection_down'
-            
-            distance = abs(current_price - price)
-            strength = self._calculate_level_strength(price, current_price, 'projection')
-            
-            levels.append(FibonacciLevel(
-                level=ratio,
-                price=price,
-                type=direction,
-                ratio=ratio,
-                distance_from_current=distance,
-                strength=strength
-            ))
-        
-        return sorted(levels, key=lambda x: x.distance_from_current)
-    
-    def _calculate_level_strength(
-        self, level_price: float, current_price: float, level_type: str
-    ) -> float:
-        """Calcula a força de um nível de Fibonacci"""
-        distance_factor = 1 / (1 + abs(level_price - current_price) / current_price)
-        
-        type_weights = {
-            'retracement': 1.0,
-            'extension': 0.8,
-            'projection': 0.6
-        }
-        
-        base_strength = type_weights.get(level_type, 0.5)
-        return base_strength * distance_factor
-    
-    def _identify_confluence_zones(
-        self, all_levels: List[FibonacciLevel]
-    ) -> List[ConfluenceZone]:
-        """Identifica zonas de confluência entre níveis"""
-        confluence_zones = []
-        
-        # Agrupar níveis próximos
-        sorted_levels = sorted(all_levels, key=lambda x: x.price)
-        
-        i = 0
-        while i < len(sorted_levels):
-            current_level = sorted_levels[i]
-            zone_levels = [current_level]
-            zone_types = [current_level.type]
-            
-            # Procurar níveis próximos
-            j = i + 1
-            while j < len(sorted_levels):
-                next_level = sorted_levels[j]
-                price_diff = abs(next_level.price - current_level.price) / current_level.price
-                
-                if price_diff <= self.confluence_threshold:
-                    zone_levels.append(next_level)
-                    zone_types.append(next_level.type)
-                    j += 1
-                else:
-                    break
-            
-            # Criar zona de confluência se houver níveis suficientes
-            if len(zone_levels) >= self.min_confluence_levels:
-                min_price = min(level.price for level in zone_levels)
-                max_price = max(level.price for level in zone_levels)
-                avg_strength = sum(level.strength for level in zone_levels) / len(zone_levels)
-                
-                confluence_zones.append(ConfluenceZone(
-                    price_range=(min_price, max_price),
-                    levels_count=len(zone_levels),
-                    strength=avg_strength * len(zone_levels),  # Força multiplicada pelo número de níveis
-                    types=list(set(zone_types))
-                ))
-            
-            i = j if j > i + 1 else i + 1
-        
-        return sorted(confluence_zones, key=lambda x: x.strength, reverse=True)
-    
-    def _detect_harmonic_patterns(
-        self, swing_high: float, swing_low: float, current_price: float,
-        historical_data: Optional[pd.DataFrame] = None
-    ) -> List[HarmonicPattern]:
-        """Detecta padrões harmônicos (implementação básica)"""
-        patterns = []
-        
-        # Implementação simplificada - pode ser expandida com dados históricos
-        swing_range = swing_high - swing_low
-        
-        for pattern_name, ratios in self.harmonic_patterns.items():
-            # Verificar se o preço atual está em uma posição válida para o padrão
-            completion_point = swing_low + (swing_range * ratios['CD'])
-            
-            if abs(current_price - completion_point) / current_price < 0.02:  # 2% de tolerância
-                confidence = 0.7  # Confiança básica
-                
-                # Calcular alvos baseados no padrão
-                target_levels = [
-                    completion_point + (swing_range * 0.382),
-                    completion_point + (swing_range * 0.618),
-                    completion_point + (swing_range * 1.0)
-                ]
-                
-                stop_loss = completion_point - (swing_range * 0.236)
-                
-                patterns.append(HarmonicPattern(
-                    name=pattern_name,
-                    completion_point=completion_point,
-                    confidence=confidence,
-                    target_levels=target_levels,
-                    stop_loss=stop_loss
-                ))
-        
-        return sorted(patterns, key=lambda x: x.confidence, reverse=True)
-    
-    def _determine_key_levels(
-        self, all_levels: List[FibonacciLevel], current_price: float
-    ) -> Tuple[float, float]:
-        """Determina níveis chave de suporte e resistência"""
-        support_levels = [level for level in all_levels if level.price < current_price]
-        resistance_levels = [level for level in all_levels if level.price > current_price]
-        
-        # Suporte mais próximo e forte
-        key_support = current_price
-        if support_levels:
-            key_support = max(support_levels, key=lambda x: x.strength).price
-        
-        # Resistência mais próxima e forte
-        key_resistance = current_price
-        if resistance_levels:
-            key_resistance = min(resistance_levels, key=lambda x: x.strength).price
-        
-        return key_support, key_resistance
-    
-    def _determine_trend_direction(
-        self, swing_high: float, swing_low: float, current_price: float
-    ) -> str:
-        """Determina direção da tendência"""
-        mid_point = (swing_high + swing_low) / 2
-        
-        if current_price > mid_point + (swing_high - swing_low) * 0.1:
-            return 'ALTA'
-        elif current_price < mid_point - (swing_high - swing_low) * 0.1:
-            return 'BAIXA'
-        else:
-            return 'LATERAL'
-    
-    def _determine_fibonacci_zone(
-        self, swing_high: float, swing_low: float, current_price: float
-    ) -> str:
-        """Determina zona de Fibonacci atual"""
-        swing_range = swing_high - swing_low
-        position = (current_price - swing_low) / swing_range
-        
-        if position >= 0.786:
-            return 'ZONA_ALTA'
-        elif position >= 0.618:
-            return 'ZONA_MEDIA_ALTA'
-        elif position >= 0.382:
-            return 'ZONA_MEDIA'
-        elif position >= 0.236:
-            return 'ZONA_MEDIA_BAIXA'
-        else:
-            return 'ZONA_BAIXA'
-    
-    def _calculate_overall_strength(
-        self, retracement_levels: List[FibonacciLevel], 
-        extension_levels: List[FibonacciLevel],
-        confluence_zones: List[ConfluenceZone],
-        harmonic_patterns: List[HarmonicPattern]
-    ) -> float:
-        """Calcula força geral da análise"""
-        # Força baseada em níveis próximos
-        level_strength = sum(level.strength for level in retracement_levels[:3])  # Top 3
-        level_strength += sum(level.strength for level in extension_levels[:3])   # Top 3
-        
-        # Força das zonas de confluência
-        confluence_strength = sum(zone.strength for zone in confluence_zones)
-        
-        # Força dos padrões harmônicos
-        harmonic_strength = sum(pattern.confidence for pattern in harmonic_patterns)
-        
-        # Normalizar para 0-1
-        total_strength = (level_strength + confluence_strength + harmonic_strength) / 10
-        return min(total_strength, 1.0)
-    
-    def _generate_trading_signal(
-        self, current_price: float, key_support: float, key_resistance: float,
-        trend_direction: str, overall_strength: float
-    ) -> str:
-        """Gera sinal de trading baseado na análise"""
-        support_distance = abs(current_price - key_support) / current_price
-        resistance_distance = abs(current_price - key_resistance) / current_price
-        
-        if overall_strength < 0.3:
-            return 'HOLD'
-        
-        if trend_direction == 'ALTA' and support_distance < 0.02:
-            return 'BUY'
-        elif trend_direction == 'BAIXA' and resistance_distance < 0.02:
-            return 'SELL'
-        elif support_distance < resistance_distance and overall_strength > 0.6:
-            return 'BUY'
-        elif resistance_distance < support_distance and overall_strength > 0.6:
-            return 'SELL'
-        else:
-            return 'HOLD'
-    
-    def format_analysis_report(self, analysis: AdvancedFibonacciAnalysis) -> str:
-        """Formata relatório da análise"""
-        report = f"""
-🔮 ANÁLISE AVANÇADA DE FIBONACCI
-{'='*50}
-
-📊 DADOS BÁSICOS:
-Swing Alto: {analysis.swing_high:,.2f}
-Swing Baixo: {analysis.swing_low:,.2f}
-Preço Atual: {analysis.current_price:,.2f}
-Range: {analysis.swing_range:,.2f}
-
-📈 NÍVEIS DE RETRACEMENT ({len(analysis.retracement_levels)}):
-"""
-        
-        for level in analysis.retracement_levels[:5]:  # Top 5
-            report += f"  {level.ratio:.1%}: {level.price:,.2f} (Força: {level.strength:.2f})\n"
-        
-        report += f"\n📊 NÍVEIS DE EXTENSÃO ({len(analysis.extension_levels)}):\n"
-        for level in analysis.extension_levels[:5]:  # Top 5
-            report += f"  {level.ratio:.1%}: {level.price:,.2f} ({level.type})\n"
-        
-        if analysis.confluence_zones:
-            report += f"\n🎯 ZONAS DE CONFLUÊNCIA ({len(analysis.confluence_zones)}):\n"
-            for zone in analysis.confluence_zones[:3]:  # Top 3
-                report += f"  {zone.price_range[0]:,.2f} - {zone.price_range[1]:,.2f} ({zone.levels_count} níveis)\n"
-        
-        if analysis.harmonic_patterns:
-            report += f"\n🎼 PADRÕES HARMÔNICOS ({len(analysis.harmonic_patterns)}):\n"
-            for pattern in analysis.harmonic_patterns:
-                report += f"  {pattern.name}: {pattern.confidence:.1%} confiança\n"
-        
-        report += f"""
-
-🎯 NÍVEIS CHAVE:
-Suporte: {analysis.key_support:,.2f}
-Resistência: {analysis.key_resistance:,.2f}
-
-📊 ANÁLISE GERAL:
-Tendência: {analysis.trend_direction}
-Zona Fibonacci: {analysis.fibonacci_zone}
-Força da Análise: {analysis.overall_strength:.1%}
-Sinal: {analysis.trading_signal}
-Alertas: {analysis.alerts_count}
-        """
-        
-        return report
-
-# Exemplo de uso
-if __name__ == "__main__":
-    engine = AdvancedFibonacciEngine()
-    
-    # Exemplo com dados do bot
-    analysis = engine.perform_advanced_analysis(
-        swing_high=140570.0,
-        swing_low=139540.0,
-        current_price=140135.0
-    )
-    
-    print(engine.format_analysis_report(analysis))

log_parser.py

@@ -1,335 +0,0 @@
-import re
-import json
-from datetime import datetime
-from typing import Dict, List, Optional, Any
-from dataclasses import dataclass, asdict
-import logging
-
-# Configurar logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-@dataclass
-class MarketData:
-    """Estrutura para dados de mercado"""
-    symbol: str
-    current_price: float
-    variation: float
-    variation_percent: float
-    high: float
-    low: float
-    volume: int
-    timestamp: str
-
-@dataclass
-class TechnicalIndicators:
-    """Estrutura para indicadores técnicos"""
-    rsi: float
-    rsi_status: str
-    ema_fast: float
-    ema_slow: float
-    ema_trend: str
-    bollinger_status: str
-    bollinger_upper: float
-    bollinger_lower: float
-    atr: float
-    volatility: str
-    volatility_multiplier: float
-
-@dataclass
-class FibonacciAnalysis:
-    """Estrutura para análise de Fibonacci"""
-    swing_high: float
-    swing_low: float
-    current_price: float
-    swing_difference: float
-    retracement_levels: int
-    extension_levels: int
-    projection_levels: int
-    total_levels: int
-    confluence_zones: int
-    harmonic_patterns: int
-    temporal_projections: int
-    analysis_strength: float
-    zone: str
-    support: float
-    resistance: float
-    alerts: int
-    signal: str
-
-@dataclass
-class BotAnalysis:
-    """Estrutura completa da análise do bot"""
-    analysis_number: int
-    timestamp: str
-    market_data: MarketData
-    technical_indicators: TechnicalIndicators
-    fibonacci_analysis: FibonacciAnalysis
-    performance_time: Optional[float] = None
-
-class VampireBotLogParser:
-    """Parser para logs do Vampire Trading Bot"""
-    
-    def __init__(self):
-        self.patterns = self._compile_patterns()
-    
-    def _compile_patterns(self) -> Dict[str, re.Pattern]:
-        """Compila padrões regex para extração de dados"""
-        return {
-            'analysis_header': re.compile(r'⏰ Análise #(\d+) - ([\d:]+)'),
-            'market_symbol': re.compile(r'📊 DADOS DE MERCADO - (\w+)'),
-            'current_price': re.compile(r'Preço Atual: ([\d.]+) ↗'),
-            'variation': re.compile(r'Variação: ([+-][\d.]+) \(([+-][\d.]+)%\)'),
-            'high_low': re.compile(r'Máxima: ([\d.]+)\nMínima: ([\d.]+)'),
-            'volume': re.compile(r'Volume: (\d+)'),
-            'rsi': re.compile(r'RSI \(14\): ([\d.]+) \((\w+)\)'),
-            'ema': re.compile(r'EMA Rápida: ([\d.]+)\nEMA Lenta: ([\d.]+)'),
-            'ema_trend': re.compile(r'Tendência EMA: (\w+)'),
-            'bollinger': re.compile(r'Bollinger: ([\w\s]+)\n\s+Superior: ([\d.]+)\n\s+Inferior: ([\d.]+)'),
-            'atr': re.compile(r'ATR: ([\d.]+)'),
-            'volatility': re.compile(r'Volatilidade: (\w+) \(([\d.]+)x\)'),
-            'swing_points': re.compile(r'📊 Swing Points - Alta: ([\d,]+\.\d+), Baixa: ([\d,]+\.\d+), Atual: ([\d,]+\.\d+)'),
-            'swing_difference': re.compile(r'📏 Diferença Swing: ([\d,]+\.\d+) pontos'),
-            'retracement_levels': re.compile(r'📈 Níveis de Retracement calculados: (\d+) níveis'),
-            'extension_levels': re.compile(r'📊 Níveis de Extensão calculados: (\d+) níveis'),
-            'projection_levels': re.compile(r'🎯 Níveis de Projeção calculados: (\d+) níveis'),
-            'total_levels': re.compile(r'🔢 Total de níveis Fibonacci: (\d+)'),
-            'confluence_zones': re.compile(r'🎯 Zonas de Confluência detectadas: (\d+)'),
-            'harmonic_patterns': re.compile(r'🎼 Padrões Harmônicos detectados: (\d+)'),
-            'temporal_projections': re.compile(r'⏰ Projeções Temporais calculadas: (\d+)'),
-            'analysis_strength': re.compile(r'💪 Força Geral da Análise: ([\d.]+)'),
-            'fibonacci_conclusion': re.compile(r'🔮 ANÁLISE CONCLUÍDA - Zona: (\w+), Suporte: ([\d.]+), Resistência: ([\d.]+)'),
-            'performance_time': re.compile(r'Análise de mercado lenta: ([\d.]+)s'),
-            'fibonacci_signal': re.compile(r'🔮 Fibonacci Avançado:\s+Alertas:(\d+) FibSinal:(\w+)')
-        }
-    
-    def parse_log_content(self, log_content: str) -> Optional[BotAnalysis]:
-        """Parseia o conteúdo completo do log"""
-        try:
-            # Extrair cabeçalho da análise
-            analysis_match = self.patterns['analysis_header'].search(log_content)
-            if not analysis_match:
-                logger.warning("Cabeçalho da análise não encontrado")
-                return None
-            
-            analysis_number = int(analysis_match.group(1))
-            timestamp = analysis_match.group(2)
-            
-            # Extrair dados de mercado
-            market_data = self._extract_market_data(log_content)
-            if not market_data:
-                logger.warning("Dados de mercado não encontrados")
-                return None
-            
-            # Extrair indicadores técnicos
-            technical_indicators = self._extract_technical_indicators(log_content)
-            if not technical_indicators:
-                logger.warning("Indicadores técnicos não encontrados")
-                return None
-            
-            # Extrair análise de Fibonacci
-            fibonacci_analysis = self._extract_fibonacci_analysis(log_content)
-            if not fibonacci_analysis:
-                logger.warning("Análise de Fibonacci não encontrada")
-                return None
-            
-            # Extrair tempo de performance (opcional)
-            performance_match = self.patterns['performance_time'].search(log_content)
-            performance_time = float(performance_match.group(1)) if performance_match else None
-            
-            return BotAnalysis(
-                analysis_number=analysis_number,
-                timestamp=timestamp,
-                market_data=market_data,
-                technical_indicators=technical_indicators,
-                fibonacci_analysis=fibonacci_analysis,
-                performance_time=performance_time
-            )
-            
-        except Exception as e:
-            logger.error(f"Erro ao parsear log: {e}")
-            return None
-    
-    def _extract_market_data(self, content: str) -> Optional[MarketData]:
-        """Extrai dados de mercado do log"""
-        try:
-            symbol_match = self.patterns['market_symbol'].search(content)
-            price_match = self.patterns['current_price'].search(content)
-            variation_match = self.patterns['variation'].search(content)
-            high_low_match = self.patterns['high_low'].search(content)
-            volume_match = self.patterns['volume'].search(content)
-            
-            if not all([symbol_match, price_match, variation_match, high_low_match, volume_match]):
-                return None
-            
-            return MarketData(
-                symbol=symbol_match.group(1),
-                current_price=float(price_match.group(1)),
-                variation=float(variation_match.group(1)),
-                variation_percent=float(variation_match.group(2)),
-                high=float(high_low_match.group(1)),
-                low=float(high_low_match.group(2)),
-                volume=int(volume_match.group(1)),
-                timestamp=datetime.now().isoformat()
-            )
-            
-        except Exception as e:
-            logger.error(f"Erro ao extrair dados de mercado: {e}")
-            return None
-    
-    def _extract_technical_indicators(self, content: str) -> Optional[TechnicalIndicators]:
-        """Extrai indicadores técnicos do log"""
-        try:
-            rsi_match = self.patterns['rsi'].search(content)
-            ema_match = self.patterns['ema'].search(content)
-            ema_trend_match = self.patterns['ema_trend'].search(content)
-            bollinger_match = self.patterns['bollinger'].search(content)
-            atr_match = self.patterns['atr'].search(content)
-            volatility_match = self.patterns['volatility'].search(content)
-            
-            if not all([rsi_match, ema_match, ema_trend_match, bollinger_match, atr_match, volatility_match]):
-                return None
-            
-            return TechnicalIndicators(
-                rsi=float(rsi_match.group(1)),
-                rsi_status=rsi_match.group(2),
-                ema_fast=float(ema_match.group(1)),
-                ema_slow=float(ema_match.group(2)),
-                ema_trend=ema_trend_match.group(1),
-                bollinger_status=bollinger_match.group(1).strip(),
-                bollinger_upper=float(bollinger_match.group(2)),
-                bollinger_lower=float(bollinger_match.group(3)),
-                atr=float(atr_match.group(1)),
-                volatility=volatility_match.group(1),
-                volatility_multiplier=float(volatility_match.group(2))
-            )
-            
-        except Exception as e:
-            logger.error(f"Erro ao extrair indicadores técnicos: {e}")
-            return None
-    
-    def _extract_fibonacci_analysis(self, content: str) -> Optional[FibonacciAnalysis]:
-        """Extrai análise de Fibonacci do log"""
-        try:
-            # Buscar pelos últimos valores (análise final)
-            swing_matches = list(self.patterns['swing_points'].finditer(content))
-            swing_diff_matches = list(self.patterns['swing_difference'].finditer(content))
-            retracement_matches = list(self.patterns['retracement_levels'].finditer(content))
-            extension_matches = list(self.patterns['extension_levels'].finditer(content))
-            projection_matches = list(self.patterns['projection_levels'].finditer(content))
-            total_matches = list(self.patterns['total_levels'].finditer(content))
-            confluence_matches = list(self.patterns['confluence_zones'].finditer(content))
-            harmonic_matches = list(self.patterns['harmonic_patterns'].finditer(content))
-            temporal_matches = list(self.patterns['temporal_projections'].finditer(content))
-            strength_matches = list(self.patterns['analysis_strength'].finditer(content))
-            conclusion_matches = list(self.patterns['fibonacci_conclusion'].finditer(content))
-            signal_match = self.patterns['fibonacci_signal'].search(content)
-            
-            if not (swing_matches and conclusion_matches and signal_match):
-                return None
-            
-            # Usar os últimos valores encontrados
-            swing_match = swing_matches[-1]
-            conclusion_match = conclusion_matches[-1]
-            
-            swing_high = float(swing_match.group(1).replace(',', ''))
-            swing_low = float(swing_match.group(2).replace(',', ''))
-            current_price = float(swing_match.group(3).replace(',', ''))
-            
-            return FibonacciAnalysis(
-                swing_high=swing_high,
-                swing_low=swing_low,
-                current_price=current_price,
-                swing_difference=float(swing_diff_matches[-1].group(1).replace(',', '')) if swing_diff_matches else 0,
-                retracement_levels=int(retracement_matches[-1].group(1)) if retracement_matches else 0,
-                extension_levels=int(extension_matches[-1].group(1)) if extension_matches else 0,
-                projection_levels=int(projection_matches[-1].group(1)) if projection_matches else 0,
-                total_levels=int(total_matches[-1].group(1)) if total_matches else 0,
-                confluence_zones=int(confluence_matches[-1].group(1)) if confluence_matches else 0,
-                harmonic_patterns=int(harmonic_matches[-1].group(1)) if harmonic_matches else 0,
-                temporal_projections=int(temporal_matches[-1].group(1)) if temporal_matches else 0,
-                analysis_strength=float(strength_matches[-1].group(1)) if strength_matches else 0.0,
-                zone=conclusion_match.group(1),
-                support=float(conclusion_match.group(2)),
-                resistance=float(conclusion_match.group(3)),
-                alerts=int(signal_match.group(1)),
-                signal=signal_match.group(2)
-            )
-            
-        except Exception as e:
-            logger.error(f"Erro ao extrair análise de Fibonacci: {e}")
-            return None
-    
-    def parse_log_file(self, file_path: str) -> Optional[BotAnalysis]:
-        """Parseia arquivo de log"""
-        try:
-            with open(file_path, 'r', encoding='utf-8') as file:
-                content = file.read()
-                return self.parse_log_content(content)
-        except Exception as e:
-            logger.error(f"Erro ao ler arquivo de log: {e}")
-            return None
-    
-    def to_dict(self, analysis: BotAnalysis) -> Dict[str, Any]:
-        """Converte análise para dicionário"""
-        return asdict(analysis)
-    
-    def to_json(self, analysis: BotAnalysis) -> str:
-        """Converte análise para JSON"""
-        return json.dumps(self.to_dict(analysis), indent=2, ensure_ascii=False)
-
-# Exemplo de uso
-if __name__ == "__main__":
-    parser = VampireBotLogParser()
-    
-    # Exemplo com o log fornecido
-    sample_log = """
-⏰ Análise #8 - 09:46:58
-
-================================================================================
-🧛 VAMPIRE TRADING BOT - ANÁLISE DETALHADA
-================================================================================
-
-📊 DADOS DE MERCADO - WINV25
-──────────────────────────────────────────────────
-Preço Atual: 140135.00000 ↗
-Variação: +5.00000 (+0.00%)
-Máxima: 140155.00000
-Mínima: 140075.00000
-Volume: 5023
-
-📈 INDICADORES TÉCNICOS
-──────────────────────────────────────────────────
-RSI (14): 46.39 (NEUTRO)
-EMA Rápida: 140192.30752
-EMA Lenta: 140221.86717
-Tendência EMA: BAIXA
-Bollinger: DENTRO DAS BANDAS
-  Superior: 140672.37317
-  Inferior: 139913.62683
-ATR: 170.73782
-Volatilidade: MÉDIA (1.23x)
-🔮 Fibonacci Avançado:  Alertas:15 FibSinal:HOLD
-    """
-    
-    # Simular dados de Fibonacci (já que não estão completos no exemplo)
-    full_sample = sample_log + """
-2025-08-27 09:46:58,333 - src.core.analysis.advanced_fibonacci - INFO - 🔮 ANÁLISE CONCLUÍDA - Zona: ZONA_MEDIA_ALTA, Suporte: 140133.28, Resistência: 140176.54
-2025-08-27 09:46:58,218 - src.core.analysis.advanced_fibonacci - INFO - 📊 Swing Points - Alta: 140,570.00, Baixa: 139,540.00, Atual: 140,135.00
-2025-08-27 09:46:58,219 - src.core.analysis.advanced_fibonacci - INFO - 📏 Diferença Swing: 1,030.00 pontos
-2025-08-27 09:46:58,244 - src.core.analysis.advanced_fibonacci - INFO - 📈 Níveis de Retracement calculados: 13 níveis
-2025-08-27 09:46:58,297 - src.core.analysis.advanced_fibonacci - INFO - 📊 Níveis de Extensão calculados: 11 níveis
-2025-08-27 09:46:58,323 - src.core.analysis.advanced_fibonacci - INFO - 🎯 Níveis de Projeção calculados: 8 níveis
-2025-08-27 09:46:58,325 - src.core.analysis.advanced_fibonacci - INFO - 🔢 Total de níveis Fibonacci: 32
-2025-08-27 09:46:58,327 - src.core.analysis.advanced_fibonacci - INFO - 🎯 Zonas de Confluência detectadas: 0
-2025-08-27 09:46:58,329 - src.core.analysis.advanced_fibonacci - INFO - 🎼 Padrões Harmônicos detectados: 0
-2025-08-27 09:46:58,332 - src.core.analysis.advanced_fibonacci - INFO - ⏰ Projeções Temporais calculadas: 0
-2025-08-27 09:46:58,332 - src.core.analysis.advanced_fibonacci - INFO - 💪 Força Geral da Análise: 0.00
-    """
-    
-    result = parser.parse_log_content(full_sample)
-    if result:
-        print("✅ Log parseado com sucesso!")
-        print(parser.to_json(result))
-    else:
-        print("❌ Erro ao parsear log")

real_time_integration.py

@@ -1,358 +0,0 @@
-import asyncio
-import os
-import time
-from datetime import datetime
-from typing import Dict, Any, Optional, Callable
-from pathlib import Path
-import json
-import logging
-from dataclasses import dataclass, asdict
-from threading import Thread, Event
-import queue
-
-from log_parser import VampireBotLogParser, BotAnalysis
-from market_analysis import TechnicalAnalysisEngine
-
-@dataclass
-class RealTimeConfig:
-    """Configuração para integração em tempo real"""
-    log_file_path: str
-    check_interval: float = 1.0  # segundos
-    max_queue_size: int = 100
-    enable_notifications: bool = True
-    auto_analysis: bool = True
-    backup_logs: bool = True
-
-@dataclass
-class BotEvent:
-    """Evento do bot em tempo real"""
-    timestamp: datetime
-    event_type: str  # 'new_analysis', 'fibonacci_alert', 'signal_change'
-    data: Dict[str, Any]
-    priority: str = 'normal'  # 'low', 'normal', 'high', 'critical'
-
-class FileWatcher:
-    """Monitor de arquivos para detectar mudanças em tempo real"""
-    
-    def __init__(self, file_path: str, callback: Callable[[str], None]):
-        self.file_path = Path(file_path)
-        self.callback = callback
-        self.last_modified = 0
-        self.last_size = 0
-        self.running = False
-        self._stop_event = Event()
-        
-    def start(self):
-        """Inicia o monitoramento do arquivo"""
-        self.running = True
-        self._stop_event.clear()
-        
-        if self.file_path.exists():
-            stat = self.file_path.stat()
-            self.last_modified = stat.st_mtime
-            self.last_size = stat.st_size
-            
-    def stop(self):
-        """Para o monitoramento"""
-        self.running = False
-        self._stop_event.set()
-        
-    def check_changes(self) -> bool:
-        """Verifica se o arquivo foi modificado"""
-        if not self.file_path.exists():
-            return False
-            
-        try:
-            stat = self.file_path.stat()
-            current_modified = stat.st_mtime
-            current_size = stat.st_size
-            
-            # Verifica se houve mudança
-            if (current_modified > self.last_modified or 
-                current_size != self.last_size):
-                
-                self.last_modified = current_modified
-                self.last_size = current_size
-                
-                # Lê o conteúdo novo
-                try:
-                    with open(self.file_path, 'r', encoding='utf-8') as f:
-                        content = f.read()
-                    self.callback(content)
-                    return True
-                except Exception as e:
-                    logging.error(f"Erro ao ler arquivo: {e}")
-                    
-        except Exception as e:
-            logging.error(f"Erro ao verificar arquivo: {e}")
-            
-        return False
-
-class RealTimeProcessor:
-    """Processador de dados em tempo real do bot"""
-    
-    def __init__(self, config: RealTimeConfig):
-        self.config = config
-        self.log_parser = VampireBotLogParser()
-        self.technical_engine = TechnicalAnalysisEngine()
-        self.event_queue = queue.Queue(maxsize=config.max_queue_size)
-        self.subscribers = []
-        self.running = False
-        self.last_analysis: Optional[BotAnalysis] = None
-        
-        # Setup logging
-        self.logger = logging.getLogger(__name__)
-        
-    def subscribe(self, callback: Callable[[BotEvent], None]):
-        """Inscreve um callback para receber eventos"""
-        self.subscribers.append(callback)
-        
-    def unsubscribe(self, callback: Callable[[BotEvent], None]):
-        """Remove um callback da lista de inscritos"""
-        if callback in self.subscribers:
-            self.subscribers.remove(callback)
-            
-    def _notify_subscribers(self, event: BotEvent):
-        """Notifica todos os inscritos sobre um evento"""
-        for callback in self.subscribers:
-            try:
-                callback(event)
-            except Exception as e:
-                self.logger.error(f"Erro ao notificar subscriber: {e}")
-                
-    def _process_new_log_data(self, log_content: str):
-        """Processa novos dados de log"""
-        try:
-            # Parse do log
-            bot_analysis = self.log_parser.parse_log(log_content)
-            
-            if bot_analysis:
-                # Verifica se é uma nova análise
-                is_new_analysis = (
-                    self.last_analysis is None or 
-                    bot_analysis.timestamp != self.last_analysis.timestamp
-                )
-                
-                if is_new_analysis:
-                    # Cria evento de nova análise
-                    event = BotEvent(
-                        timestamp=datetime.now(),
-                        event_type='new_analysis',
-                        data=asdict(bot_analysis),
-                        priority='normal'
-                    )
-                    
-                    # Adiciona à fila de eventos
-                    try:
-                        self.event_queue.put_nowait(event)
-                    except queue.Full:
-                        self.logger.warning("Fila de eventos cheia, removendo evento mais antigo")
-                        try:
-                            self.event_queue.get_nowait()
-                            self.event_queue.put_nowait(event)
-                        except queue.Empty:
-                            pass
-                    
-                    # Verifica alertas de Fibonacci
-                    if bot_analysis.fibonacci_analysis and bot_analysis.fibonacci_analysis.alerts:
-                        fib_event = BotEvent(
-                            timestamp=datetime.now(),
-                            event_type='fibonacci_alert',
-                            data={
-                                'alerts': bot_analysis.fibonacci_analysis.alerts,
-                                'signal': bot_analysis.fibonacci_analysis.signal,
-                                'confidence': bot_analysis.fibonacci_analysis.confidence
-                            },
-                            priority='high'
-                        )
-                        
-                        try:
-                            self.event_queue.put_nowait(fib_event)
-                        except queue.Full:
-                            pass
-                    
-                    # Verifica mudança de sinal
-                    if (self.last_analysis and 
-                        bot_analysis.fibonacci_analysis and 
-                        self.last_analysis.fibonacci_analysis and
-                        bot_analysis.fibonacci_analysis.signal != self.last_analysis.fibonacci_analysis.signal):
-                        
-                        signal_event = BotEvent(
-                            timestamp=datetime.now(),
-                            event_type='signal_change',
-                            data={
-                                'old_signal': self.last_analysis.fibonacci_analysis.signal,
-                                'new_signal': bot_analysis.fibonacci_analysis.signal,
-                                'confidence': bot_analysis.fibonacci_analysis.confidence
-                            },
-                            priority='critical'
-                        )
-                        
-                        try:
-                            self.event_queue.put_nowait(signal_event)
-                        except queue.Full:
-                            pass
-                    
-                    self.last_analysis = bot_analysis
-                    
-        except Exception as e:
-            self.logger.error(f"Erro ao processar log: {e}")
-            
-    def _event_processor_loop(self):
-        """Loop principal de processamento de eventos"""
-        while self.running:
-            try:
-                # Processa eventos da fila
-                try:
-                    event = self.event_queue.get(timeout=0.1)
-                    self._notify_subscribers(event)
-                    self.event_queue.task_done()
-                except queue.Empty:
-                    continue
-                    
-            except Exception as e:
-                self.logger.error(f"Erro no loop de eventos: {e}")
-                time.sleep(0.1)
-                
-    def start(self):
-        """Inicia o processamento em tempo real"""
-        if self.running:
-            return
-            
-        self.running = True
-        self.logger.info("Iniciando processamento em tempo real")
-        
-        # Inicia thread de processamento de eventos
-        self.event_thread = Thread(target=self._event_processor_loop, daemon=True)
-        self.event_thread.start()
-        
-        # Configura watcher de arquivo
-        self.file_watcher = FileWatcher(
-            self.config.log_file_path,
-            self._process_new_log_data
-        )
-        self.file_watcher.start()
-        
-        # Inicia thread de monitoramento
-        self.monitor_thread = Thread(target=self._monitor_loop, daemon=True)
-        self.monitor_thread.start()
-        
-    def stop(self):
-        """Para o processamento em tempo real"""
-        if not self.running:
-            return
-            
-        self.logger.info("Parando processamento em tempo real")
-        self.running = False
-        
-        if hasattr(self, 'file_watcher'):
-            self.file_watcher.stop()
-            
-    def _monitor_loop(self):
-        """Loop de monitoramento de arquivo"""
-        while self.running:
-            try:
-                self.file_watcher.check_changes()
-                time.sleep(self.config.check_interval)
-            except Exception as e:
-                self.logger.error(f"Erro no monitoramento: {e}")
-                time.sleep(1)
-                
-    def get_status(self) -> Dict[str, Any]:
-        """Retorna status do processador"""
-        return {
-            'running': self.running,
-            'queue_size': self.event_queue.qsize(),
-            'subscribers_count': len(self.subscribers),
-            'last_analysis_time': self.last_analysis.timestamp if self.last_analysis else None,
-            'config': asdict(self.config)
-        }
-
-class RealTimeIntegration:
-    """Sistema principal de integração em tempo real"""
-    
-    def __init__(self, log_file_path: str):
-        self.config = RealTimeConfig(log_file_path=log_file_path)
-        self.processor = RealTimeProcessor(self.config)
-        self.event_history = []
-        self.max_history = 1000
-        
-        # Setup logging
-        self.logger = logging.getLogger(__name__)
-        
-        # Inscreve callback padrão
-        self.processor.subscribe(self._default_event_handler)
-        
-    def _default_event_handler(self, event: BotEvent):
-        """Handler padrão para eventos"""
-        # Adiciona ao histórico
-        self.event_history.append(event)
-        
-        # Mantém tamanho do histórico
-        if len(self.event_history) > self.max_history:
-            self.event_history = self.event_history[-self.max_history:]
-            
-        # Log do evento
-        self.logger.info(f"Evento {event.event_type} - Prioridade: {event.priority}")
-        
-        # Processamento específico por tipo
-        if event.event_type == 'signal_change':
-            self.logger.warning(
-                f"MUDANÇA DE SINAL: {event.data['old_signal']} -> {event.data['new_signal']} "
-                f"(Confiança: {event.data['confidence']}%)"
-            )
-        elif event.event_type == 'fibonacci_alert':
-            self.logger.info(f"Alerta Fibonacci: {len(event.data['alerts'])} alertas")
-            
-    def start(self):
-        """Inicia a integração em tempo real"""
-        self.processor.start()
-        self.logger.info(f"Integração em tempo real iniciada para: {self.config.log_file_path}")
-        
-    def stop(self):
-        """Para a integração em tempo real"""
-        self.processor.stop()
-        self.logger.info("Integração em tempo real parada")
-        
-    def get_recent_events(self, limit: int = 10) -> list[BotEvent]:
-        """Retorna eventos recentes"""
-        return self.event_history[-limit:] if self.event_history else []
-        
-    def get_status(self) -> Dict[str, Any]:
-        """Retorna status completo do sistema"""
-        processor_status = self.processor.get_status()
-        return {
-            **processor_status,
-            'event_history_size': len(self.event_history),
-            'recent_events': len([e for e in self.event_history if 
-                                (datetime.now() - e.timestamp).seconds < 300])  # últimos 5 min
-        }
-
-# Exemplo de uso
-if __name__ == "__main__":
-    # Configurar logging
-    logging.basicConfig(level=logging.INFO)
-    
-    # Criar integração
-    integration = RealTimeIntegration("d:/hugging_face_spaces/text")
-    
-    # Callback personalizado
-    def custom_handler(event: BotEvent):
-        print(f"[{event.timestamp}] {event.event_type}: {event.priority}")
-        
-    integration.processor.subscribe(custom_handler)
-    
-    try:
-        # Iniciar
-        integration.start()
-        
-        # Manter rodando
-        while True:
-            time.sleep(1)
-            status = integration.get_status()
-            if status['recent_events'] > 0:
-                print(f"Eventos recentes: {status['recent_events']}")
-                
-    except KeyboardInterrupt:
-        print("Parando integração...")
-        integration.stop()

requirements.txt

@@ -1,6 +1,39 @@
-gradio==4.44.0
+# Core dependencies
+gradio==5.44.0
 transformers==4.36.0
 torch>=2.0.0
 numpy>=1.24.0
 pandas>=2.0.0
-scipy>=1.11.0
+scipy>=1.11.0
+
+# Machine Learning
+scikit-learn>=1.3.0
+xgboost>=1.7.0
+lightgbm>=4.0.0
+
+# Data processing
+ta>=0.10.2
+yfinance>=0.2.18
+requests>=2.31.0
+
+# Visualization
+matplotlib>=3.7.0
+plotly>=5.15.0
+seaborn>=0.12.0
+
+# Utilities
+tqdm>=4.65.0
+joblib>=1.3.0
+psutil>=5.9.0
+
+# Development and testing
+pytest>=7.4.0
+pytest-cov>=4.1.0
+flake8>=6.0.0
+black>=23.0.0
+
+# Optional dependencies for advanced features
+# Uncomment if needed:
+# tensorflow>=2.13.0
+# keras>=2.13.0
+# optuna>=3.3.0

sentiment_analysis.py

@@ -1,331 +0,0 @@
-"""Módulo de análise de sentimento usando IA financeira."""
-
-import re
-from typing import Dict, Optional, Any
-from dataclasses import dataclass
-
-from config import FINANCIAL_MODELS, AIConfig, AppConfig
-
-# Importações opcionais para IA
-try:
-    from transformers import pipeline
-    import torch
-    TRANSFORMERS_AVAILABLE = True
-except ImportError:
-    TRANSFORMERS_AVAILABLE = False
-    print(AppConfig.STATUS_MESSAGES['AI_UNAVAILABLE'])
-
-
-@dataclass
-class SentimentResult:
-    """Classe para representar resultado de análise de sentimento."""
-    sentiment: str  # 'positive', 'negative', 'neutral'
-    confidence: float  # 0.0 - 1.0
-    label: str  # 'POSITIVO', 'NEGATIVO', 'NEUTRO'
-    model_used: Optional[str] = None
-
-
-class ModelManager:
-    """Gerenciador de modelos de IA."""
-    
-    def __init__(self):
-        self.sentiment_pipeline = None
-        self.current_model_info = None
-        self.is_available = TRANSFORMERS_AVAILABLE
-        
-        if self.is_available:
-            self._load_models()
-    
-    def _load_models(self) -> None:
-        """Tenta carregar modelos em ordem de prioridade."""
-        for model_config in FINANCIAL_MODELS:
-            try:
-                print(AppConfig.STATUS_MESSAGES['AI_LOADING'].format(
-                    model_config['description']
-                ))
-                
-                self.sentiment_pipeline = pipeline(
-                    AIConfig.PIPELINE_CONFIG['task'],
-                    model=model_config["name"],
-                    return_all_scores=AIConfig.PIPELINE_CONFIG['return_all_scores']
-                )
-                
-                self.current_model_info = model_config
-                print(AppConfig.STATUS_MESSAGES['AI_SUCCESS'].format(
-                    model_config['description']
-                ))
-                break
-                
-            except Exception as e:
-                print(AppConfig.STATUS_MESSAGES['AI_FAILED'].format(
-                    model_config['name'], str(e)
-                ))
-                continue
-        
-        if self.sentiment_pipeline is None:
-            print(AppConfig.STATUS_MESSAGES['NO_MODEL_LOADED'])
-            self.is_available = False
-    
-    def get_model_info(self) -> Optional[Dict[str, Any]]:
-        """Retorna informações do modelo atual."""
-        return self.current_model_info
-    
-    def is_model_available(self) -> bool:
-        """Verifica se há modelo disponível."""
-        return self.is_available and self.sentiment_pipeline is not None
-
-
-class TextPreprocessor:
-    """Pré-processador de texto para análise de sentimento."""
-    
-    @staticmethod
-    def clean_text(text: str) -> str:
-        """Limpa e prepara texto para análise."""
-        if not text:
-            return ""
-        
-        # Remover caracteres especiais, manter apenas palavras, espaços e alguns símbolos
-        clean_text = re.sub(r'[^\w\s\+\-\%\.]', ' ', text)
-        
-        # Limitar tamanho para o modelo
-        clean_text = clean_text[:AIConfig.MAX_TEXT_LENGTH]
-        
-        # Remover espaços extras
-        clean_text = ' '.join(clean_text.split())
-        
-        return clean_text
-    
-    @staticmethod
-    def extract_financial_keywords(text: str) -> Dict[str, int]:
-        """Extrai palavras-chave financeiras do texto."""
-        financial_keywords = {
-            'positive': ['alta', 'subida', 'ganho', 'lucro', 'crescimento', 'otimista', 'positivo'],
-            'negative': ['baixa', 'queda', 'perda', 'prejuízo', 'declínio', 'pessimista', 'negativo'],
-            'neutral': ['estável', 'neutro', 'lateral', 'consolidação']
-        }
-        
-        text_lower = text.lower()
-        keyword_counts = {'positive': 0, 'negative': 0, 'neutral': 0}
-        
-        for category, keywords in financial_keywords.items():
-            for keyword in keywords:
-                keyword_counts[category] += text_lower.count(keyword)
-        
-        return keyword_counts
-
-
-class SentimentAnalyzer:
-    """Analisador de sentimento principal."""
-    
-    def __init__(self, model_manager: ModelManager):
-        self.model_manager = model_manager
-        self.preprocessor = TextPreprocessor()
-    
-    def analyze(self, text: str) -> SentimentResult:
-        """Analisa o sentimento do texto."""
-        if not self.model_manager.is_model_available():
-            return self._get_fallback_sentiment(text)
-        
-        try:
-            # Pré-processar texto
-            clean_text = self.preprocessor.clean_text(text)
-            
-            if not clean_text.strip():
-                return SentimentResult(
-                    sentiment='neutral',
-                    confidence=0.5,
-                    label='NEUTRO',
-                    model_used='fallback'
-                )
-            
-            # Executar análise de sentimento
-            result = self.model_manager.sentiment_pipeline(clean_text)
-            
-            # Processar resultado
-            return self._process_model_result(result)
-            
-        except Exception as e:
-            print(f"Erro na análise de sentimento: {e}")
-            return self._get_fallback_sentiment(text)
-    
-    def _process_model_result(self, result: Any) -> SentimentResult:
-        """Processa resultado do modelo de IA."""
-        try:
-            # Processar resultado baseado no formato
-            if isinstance(result, list) and len(result) > 0:
-                # Se return_all_scores=True, pegar o resultado com maior score
-                if isinstance(result[0], list):
-                    predictions = result[0]
-                    best_prediction = max(predictions, key=lambda x: x['score'])
-                else:
-                    best_prediction = result[0]
-                
-                # Mapear label usando o mapeamento do modelo atual
-                label = best_prediction['label']
-                confidence = best_prediction['score']
-                
-                # Usar mapeamento específico do modelo ou fallback genérico
-                model_info = self.model_manager.get_model_info()
-                if model_info and label in model_info['labels']:
-                    sentiment_label = model_info['labels'][label]
-                else:
-                    # Fallback para mapeamento genérico
-                    sentiment_label = self._map_generic_label(label)
-                
-                return SentimentResult(
-                    sentiment=label.lower(),
-                    confidence=confidence,
-                    label=sentiment_label,
-                    model_used=model_info['name'] if model_info else 'unknown'
-                )
-            
-            # Fallback se resultado não esperado
-            return SentimentResult(
-                sentiment='neutral',
-                confidence=0.5,
-                label='NEUTRO',
-                model_used='fallback'
-            )
-            
-        except Exception as e:
-            print(f"Erro ao processar resultado do modelo: {e}")
-            return SentimentResult(
-                sentiment='neutral',
-                confidence=0.5,
-                label='NEUTRO',
-                model_used='error_fallback'
-            )
-    
-    def _map_generic_label(self, label: str) -> str:
-        """Mapeia labels genéricos para formato padrão."""
-        label_lower = label.lower()
-        
-        if 'neg' in label_lower or 'bad' in label_lower:
-            return 'NEGATIVO'
-        elif 'pos' in label_lower or 'good' in label_lower:
-            return 'POSITIVO'
-        else:
-            return 'NEUTRO'
-    
-    def _get_fallback_sentiment(self, text: str) -> SentimentResult:
-        """Análise de sentimento baseada em palavras-chave (fallback)."""
-        if not text:
-            return SentimentResult(
-                sentiment='neutral',
-                confidence=0.5,
-                label='NEUTRO',
-                model_used='keyword_fallback'
-            )
-        
-        # Análise baseada em palavras-chave
-        keyword_counts = self.preprocessor.extract_financial_keywords(text)
-        
-        total_keywords = sum(keyword_counts.values())
-        if total_keywords == 0:
-            return SentimentResult(
-                sentiment='neutral',
-                confidence=0.5,
-                label='NEUTRO',
-                model_used='keyword_fallback'
-            )
-        
-        # Determinar sentimento dominante
-        max_category = max(keyword_counts, key=keyword_counts.get)
-        max_count = keyword_counts[max_category]
-        confidence = min(0.8, max_count / total_keywords)  # Máximo 80% de confiança
-        
-        sentiment_mapping = {
-            'positive': ('positive', 'POSITIVO'),
-            'negative': ('negative', 'NEGATIVO'),
-            'neutral': ('neutral', 'NEUTRO')
-        }
-        
-        sentiment, label = sentiment_mapping[max_category]
-        
-        return SentimentResult(
-            sentiment=sentiment,
-            confidence=confidence,
-            label=label,
-            model_used='keyword_fallback'
-        )
-
-
-class SentimentScorer:
-    """Calculador de pontuação baseada em sentimento."""
-    
-    @staticmethod
-    def calculate_sentiment_score(sentiment_result: SentimentResult) -> int:
-        """Calcula pontuação de confiança baseada no sentimento."""
-        from config import ScoringConfig
-        
-        base_score = int(sentiment_result.confidence * ScoringConfig.SENTIMENT_MAX_SCORE)
-        
-        # Bonificação por modelo de IA vs fallback
-        if sentiment_result.model_used and 'fallback' not in sentiment_result.model_used:
-            base_score = int(base_score * 1.2)  # 20% de bonificação para modelos de IA
-        
-        return min(base_score, ScoringConfig.SENTIMENT_MAX_SCORE)
-    
-    @staticmethod
-    def get_sentiment_signal_description(sentiment_result: SentimentResult) -> str:
-        """Gera descrição do sinal de sentimento."""
-        confidence_pct = sentiment_result.confidence * 100
-        
-        if sentiment_result.label == 'POSITIVO':
-            bias = "viés de COMPRA"
-        elif sentiment_result.label == 'NEGATIVO':
-            bias = "viés de VENDA"
-        else:
-            bias = "sem viés claro"
-        
-        model_indicator = "🤖 IA" if 'fallback' not in (sentiment_result.model_used or '') else "📝 Palavras-chave"
-        
-        return f"{model_indicator} Sentimento: {sentiment_result.label} ({confidence_pct:.1f}%): {bias}"
-
-
-class SentimentAnalysisEngine:
-    """Engine principal de análise de sentimento."""
-    
-    def __init__(self):
-        self.model_manager = ModelManager()
-        self.analyzer = SentimentAnalyzer(self.model_manager)
-        self.scorer = SentimentScorer()
-    
-    def analyze_text(self, text: str) -> Dict[str, Any]:
-        """Executa análise completa de sentimento."""
-        # Análise de sentimento
-        sentiment_result = self.analyzer.analyze(text)
-        
-        # Calcular pontuação
-        score = self.scorer.calculate_sentiment_score(sentiment_result)
-        
-        # Gerar descrição
-        description = self.scorer.get_sentiment_signal_description(sentiment_result)
-        
-        return {
-            'result': sentiment_result,
-            'score': score,
-            'description': description
-        }
-    
-    def get_model_status(self) -> Dict[str, Any]:
-        """Retorna status do modelo atual."""
-        if self.model_manager.is_model_available():
-            model_info = self.model_manager.get_model_info()
-            return {
-                'available': True,
-                'model_name': model_info['name'] if model_info else 'Unknown',
-                'description': model_info['description'] if model_info else 'Unknown Model',
-                'status': 'active'
-            }
-        else:
-            return {
-                'available': False,
-                'model_name': None,
-                'description': 'IA indisponível - usando análise por palavras-chave',
-                'status': 'fallback'
-            }
-    
-    def is_available(self) -> bool:
-        """Verifica se análise de IA está disponível."""
-        return self.model_manager.is_model_available()

src/ui/gradio_interface.py

@@ -13,6 +13,12 @@ from src.utils.utils import (
     FormatUtils
 )
 
+# Importar sistema de logging
+try:
+    from src.utils.request_logger import log_requests_responses
+except ImportError:
+    log_requests_responses = None
+
 
 class UIComponents:
     """Componentes da interface do usuário."""
@@ -568,6 +574,7 @@ class GradioInterface:
         self.model_info = model_info or {'available': False}
         self.interface = None
     
+    @log_requests_responses("analyze_market") if log_requests_responses else lambda f: f
     def analyze_market(self, symbol, price, volume, sentiment_text):
         """Função principal de análise"""
         try:
@@ -597,6 +604,7 @@ class GradioInterface:
         except Exception as e:
             return f"❌ Erro na análise: {str(e)}"
     
+    @log_requests_responses("analyze_bot_log") if log_requests_responses else lambda f: f
     def analyze_bot_log(self, log_content):
         """Função para analisar logs do bot externo"""
         try:
@@ -689,6 +697,7 @@ class GradioInterface:
         self.interface = interface
         return interface
     
+    @log_requests_responses("_analyze_wrapper") if log_requests_responses else lambda f: f
     def _analyze_wrapper(self, market_input: str) -> Tuple[str, str, str, str, str, str, str, Dict[str, Any]]:
         """Wrapper para função de análise com formatação de saída."""
         try:
@@ -745,6 +754,7 @@ class GradioInterface:
                 {'error': error_msg}
             )
     
+    @log_requests_responses("_analyze_manual_wrapper") if log_requests_responses else lambda f: f
     def _analyze_manual_wrapper(self, symbol: str, price: float, volume: float, sentiment_text: str) -> Tuple[str, str, str, str, str, str, str, Dict[str, Any]]:
         """Wrapper para análise manual com formatação de saída."""
         try:

src/utils/request_logger.py

@@ -0,0 +1,194 @@
+"""Módulo de logging para requisições e respostas HTTP."""
+
+import json
+import time
+from datetime import datetime
+from typing import Dict, Any, Optional
+from functools import wraps
+import inspect
+
+
+class RequestResponseLogger:
+    """Logger para capturar dados de requisições e respostas."""
+    
+    def __init__(self, enabled: bool = True):
+        """Inicializa o logger.
+        
+        Args:
+            enabled: Se o logging está habilitado
+        """
+        self.enabled = enabled
+        self.request_counter = 0
+    
+    def log_request(self, endpoint: str, data: Dict[str, Any], method: str = "POST") -> str:
+        """Registra dados da requisição recebida.
+        
+        Args:
+            endpoint: Nome do endpoint/função chamada
+            data: Dados recebidos na requisição
+            method: Método HTTP (GET, POST, etc.)
+            
+        Returns:
+            ID único da requisição
+        """
+        if not self.enabled:
+            return ""
+            
+        self.request_counter += 1
+        request_id = f"REQ_{self.request_counter}_{int(time.time())}"
+        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]
+        
+        print("\n" + "="*80)
+        print(f"📥 REQUISIÇÃO RECEBIDA [{request_id}]")
+        print(f"⏰ Timestamp: {timestamp}")
+        print(f"🎯 Endpoint: {endpoint}")
+        print(f"🔧 Método: {method}")
+        print("📋 Dados Recebidos:")
+        
+        # Formatar dados de forma legível
+        try:
+            formatted_data = json.dumps(data, indent=2, ensure_ascii=False, default=str)
+            print(formatted_data)
+        except Exception as e:
+            print(f"  {data} (Erro na formatação JSON: {e})")
+        
+        print("="*80)
+        
+        return request_id
+    
+    def log_response(self, request_id: str, response_data: Any, processing_time: float = None) -> None:
+        """Registra dados da resposta enviada.
+        
+        Args:
+            request_id: ID da requisição correspondente
+            response_data: Dados enviados como resposta
+            processing_time: Tempo de processamento em segundos
+        """
+        if not self.enabled:
+            return
+            
+        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]
+        
+        print("\n" + "-"*80)
+        print(f"📤 RESPOSTA ENVIADA [{request_id}]")
+        print(f"⏰ Timestamp: {timestamp}")
+        
+        if processing_time is not None:
+            print(f"⚡ Tempo de Processamento: {processing_time:.3f}s")
+        
+        print("📋 Dados Enviados:")
+        
+        # Formatar resposta de forma legível
+        try:
+            if isinstance(response_data, (dict, list)):
+                formatted_response = json.dumps(response_data, indent=2, ensure_ascii=False, default=str)
+                print(formatted_response)
+            elif isinstance(response_data, str) and len(response_data) > 500:
+                # Para strings muito longas, mostrar apenas o início e fim
+                print(f"  [STRING LONGA - {len(response_data)} caracteres]")
+                print(f"  Início: {response_data[:200]}...")
+                print(f"  Fim: ...{response_data[-200:]}")
+            else:
+                print(f"  {response_data}")
+        except Exception as e:
+            print(f"  {response_data} (Erro na formatação: {e})")
+        
+        print("-"*80 + "\n")
+    
+    def log_error(self, request_id: str, error: Exception, processing_time: float = None) -> None:
+        """Registra erro durante o processamento.
+        
+        Args:
+            request_id: ID da requisição correspondente
+            error: Exceção ocorrida
+            processing_time: Tempo até o erro em segundos
+        """
+        if not self.enabled:
+            return
+            
+        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]
+        
+        print("\n" + "!"*80)
+        print(f"❌ ERRO NO PROCESSAMENTO [{request_id}]")
+        print(f"⏰ Timestamp: {timestamp}")
+        
+        if processing_time is not None:
+            print(f"⚡ Tempo até Erro: {processing_time:.3f}s")
+        
+        print(f"🚨 Tipo do Erro: {type(error).__name__}")
+        print(f"📝 Mensagem: {str(error)}")
+        print("!"*80 + "\n")
+
+
+# Instância global do logger
+request_logger = RequestResponseLogger()
+
+
+def log_requests_responses(endpoint_name: str = None):
+    """Decorator para automaticamente logar requisições e respostas de funções.
+    
+    Args:
+        endpoint_name: Nome personalizado para o endpoint (opcional)
+    """
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            if not request_logger.enabled:
+                return func(*args, **kwargs)
+            
+            # Determinar nome do endpoint
+            endpoint = endpoint_name or func.__name__
+            
+            # Capturar dados da requisição
+            request_data = {
+                'args': args,
+                'kwargs': kwargs,
+                'function_signature': str(inspect.signature(func))
+            }
+            
+            # Logar requisição
+            request_id = request_logger.log_request(endpoint, request_data)
+            
+            # Executar função e medir tempo
+            start_time = time.time()
+            try:
+                result = func(*args, **kwargs)
+                processing_time = time.time() - start_time
+                
+                # Logar resposta
+                request_logger.log_response(request_id, result, processing_time)
+                
+                return result
+                
+            except Exception as e:
+                processing_time = time.time() - start_time
+                
+                # Logar erro
+                request_logger.log_error(request_id, e, processing_time)
+                
+                # Re-raise a exceção
+                raise
+        
+        return wrapper
+    return decorator
+
+
+def enable_logging():
+    """Habilita o logging de requisições/respostas."""
+    request_logger.enabled = True
+    print("✅ Logging de requisições/respostas HABILITADO")
+
+
+def disable_logging():
+    """Desabilita o logging de requisições/respostas."""
+    request_logger.enabled = False
+    print("❌ Logging de requisições/respostas DESABILITADO")
+
+
+def get_logging_status() -> bool:
+    """Retorna o status atual do logging.
+    
+    Returns:
+        True se o logging está habilitado, False caso contrário
+    """
+    return request_logger.enabled

ui.py

@@ -1,818 +0,0 @@
-"""Módulo de interface do usuário com Gradio."""
-
-import gradio as gr
-from typing import Dict, Any, Optional, Tuple
-
-from config import UIConfig, AppConfig
-from utils import (
-    DateTimeUtils,
-    NumberUtils,
-    ConfidenceUtils,
-    ActionUtils,
-    SentimentUtils,
-    FormatUtils
-)
-
-
-class UIComponents:
-    """Componentes da interface do usuário."""
-    
-    @staticmethod
-    def create_header() -> str:
-        """
-    
-    @staticmethod
-    def format_harmonic_patterns(analysis_result: Dict[str, Any]) -> str:
-        """Formata padrões harmônicos detectados."""
-        harmonic_patterns = analysis_result.get('harmonic_patterns', [])
-        
-        if not harmonic_patterns:
-            return """
-            <div style="background: white; border-radius: 8px; padding: 20px; border: 1px solid #dee2e6;">
-                <h3 style="color: #495057; margin-top: 0;">🎵 Padrões Harmônicos</h3>
-                <div style="text-align: center; padding: 30px; color: #6c757d;">
-                    <div style="font-size: 2em; margin-bottom: 10px;">📊</div>
-                    <p>Nenhum padrão harmônico detectado</p>
-                </div>
-            </div>
-            """
-        
-        patterns_html = ""
-        for pattern in harmonic_patterns:
-            pattern_name = pattern.get('name', 'Desconhecido')
-            confidence = pattern.get('confidence', 0)
-            direction = pattern.get('direction', 'NEUTRO')
-            
-            direction_emoji = "📈" if direction == "ALTA" else "📉" if direction == "BAIXA" else "➡️"
-            
-            patterns_html += f"""
-            <div style="background: #f8f9fa; border-radius: 6px; padding: 15px; margin-bottom: 10px; border-left: 4px solid #007bff;">
-                <div style="display: flex; justify-content: space-between; align-items: center;">
-                    <div>
-                        <strong style="color: #495057;">{direction_emoji} {pattern_name}</strong>
-                        <div style="color: #6c757d; font-size: 0.9em;">Direção: {direction}</div>
-                    </div>
-                    <div style="text-align: right;">
-                        <div style="font-weight: bold; color: #007bff;">{confidence}%</div>
-                        <div style="color: #6c757d; font-size: 0.8em;">Confiança</div>
-                    </div>
-                </div>
-            </div>
-            """
-        
-        return f"""
-        <div style="background: white; border-radius: 8px; padding: 20px; border: 1px solid #dee2e6;">
-            <h3 style="color: #495057; margin-top: 0; border-bottom: 2px solid #007bff; padding-bottom: 10px;">
-                🎵 Padrões Harmônicos Detectados
-            </h3>
-            {patterns_html}
-        </div>
-        """
-    
-    @staticmethod
-    def format_fibonacci_alerts(analysis_result: Dict[str, Any]) -> str:
-        """Formata alertas de Fibonacci."""
-        fibonacci_data = analysis_result.get('fibonacci_analysis', {})
-        
-        if not fibonacci_data:
-            return """
-            <div style="background: white; border-radius: 8px; padding: 20px; border: 1px solid #dee2e6;">
-                <h3 style="color: #495057; margin-top: 0;">📐 Análise de Fibonacci</h3>
-                <div style="text-align: center; padding: 30px; color: #6c757d;">
-                    <div style="font-size: 2em; margin-bottom: 10px;">📊</div>
-                    <p>Dados de Fibonacci não disponíveis</p>
-                </div>
-            </div>
-            """
-        
-        levels = fibonacci_data.get('levels', [])
-        current_level = fibonacci_data.get('current_level', 'N/A')
-        support_resistance = fibonacci_data.get('support_resistance', {})
-        
-        levels_html = ""
-        for level in levels:
-            level_value = level.get('level', 0)
-            price = level.get('price', 0)
-            status = level.get('status', 'NEUTRO')
-            
-            status_color = {
-                'SUPORTE': '#28a745',
-                'RESISTENCIA': '#dc3545',
-                'NEUTRO': '#6c757d'
-            }.get(status, '#6c757d')
-            
-            levels_html += f"""
-            <div style="display: flex; justify-content: space-between; padding: 8px 0; border-bottom: 1px solid #eee;">
-                <span style="color: #495057;">{level_value}%</span>
-                <span style="font-weight: bold; color: #495057;">{NumberUtils.format_price(price)}</span>
-                <span style="color: {status_color}; font-weight: 600;">{status}</span>
-            </div>
-            """
-        
-        return f"""
-         <div style="background: white; border-radius: 8px; padding: 20px; border: 1px solid #dee2e6;">
-             <h3 style="color: #495057; margin-top: 0; border-bottom: 2px solid #ffc107; padding-bottom: 10px;">
-                 📐 Análise de Fibonacci
-             </h3>
-             
-             <div style="background: #fff3cd; border: 1px solid #ffeaa7; border-radius: 6px; padding: 15px; margin-bottom: 15px;">
-                 <strong style="color: #856404;">Nível Atual: {current_level}</strong>
-             </div>
-             
-             <h4 style="color: #495057; margin-bottom: 10px;">📊 Níveis de Fibonacci</h4>
-             <div style="background: #f8f9fa; border-radius: 6px; padding: 15px;">
-                 <div style="display: flex; justify-content: space-between; font-weight: bold; color: #495057; border-bottom: 2px solid #dee2e6; padding-bottom: 8px; margin-bottom: 10px;">
-                     <span>Nível</span>
-                     <span>Preço</span>
-                     <span>Status</span>
-                 </div>
-                 {levels_html}
-             </div>
-         </div>
-         """
-    
-    @staticmethod
-    def format_bot_analysis_result(analysis_result: Dict[str, Any]) -> str:
-        """Formata resultado específico da análise do bot externo."""
-        try:
-            bot_data = analysis_result.get('bot_data', {})
-            fibonacci_alerts = bot_data.get('fibonacci_alerts', 0)
-            fibonacci_signal = bot_data.get('fibonacci_signal', 'UNKNOWN')
-            technical_indicators = bot_data.get('technical_indicators', {})
-            
-            # Formatação do sinal Fibonacci
-            signal_color = {
-                'BUY': '#28a745',
-                'SELL': '#dc3545', 
-                'HOLD': '#ffc107',
-                'UNKNOWN': '#6c757d'
-            }.get(fibonacci_signal, '#6c757d')
-            
-            signal_emoji = {
-                'BUY': '📈',
-                'SELL': '📉',
-                'HOLD': '⏸️',
-                'UNKNOWN': '❓'
-            }.get(fibonacci_signal, '❓')
-            
-            # Indicadores técnicos do bot
-            indicators_html = ""
-            for indicator, value in technical_indicators.items():
-                if value is not None:
-                    indicators_html += f"""
-                    <div style="display: flex; justify-content: space-between; padding: 8px 0; border-bottom: 1px solid #eee;">
-                        <span style="color: #495057; text-transform: uppercase;">{indicator}</span>
-                        <span style="font-weight: bold; color: #495057;">{value}</span>
-                    </div>
-                    """
-            
-            return f"""
-            <div style="background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); border-radius: 12px; padding: 25px; color: white; margin-bottom: 20px;">
-                <h2 style="margin-top: 0; display: flex; align-items: center; gap: 10px;">
-                    🤖 Análise do Bot de Trading
-                </h2>
-                
-                <div style="display: grid; grid-template-columns: 1fr 1fr; gap: 20px; margin-top: 20px;">
-                    <div style="background: rgba(255,255,255,0.1); border-radius: 8px; padding: 15px;">
-                        <h4 style="margin-top: 0; color: #f8f9fa;">📐 Fibonacci</h4>
-                        <div style="display: flex; align-items: center; gap: 10px; margin-bottom: 10px;">
-                            <span style="font-size: 1.5em;">{signal_emoji}</span>
-                            <div>
-                                <div style="font-weight: bold; font-size: 1.1em; color: {signal_color};">{fibonacci_signal}</div>
-                                <div style="font-size: 0.9em; opacity: 0.8;">Sinal Atual</div>
-                            </div>
-                        </div>
-                        <div style="font-size: 0.9em; opacity: 0.8;">Alertas: {fibonacci_alerts}</div>
-                    </div>
-                    
-                    <div style="background: rgba(255,255,255,0.1); border-radius: 8px; padding: 15px;">
-                        <h4 style="margin-top: 0; color: #f8f9fa;">📊 Indicadores</h4>
-                        <div style="font-size: 0.9em;">
-                            {indicators_html if indicators_html else '<div style="opacity: 0.8;">Dados não disponíveis</div>'}
-                        </div>
-                    </div>
-                </div>
-            </div>
-            
-            {ResultFormatter.format_main_result(analysis_result)}
-            """
-            
-        except Exception as e:
-            return f"""
-            <div style="background: #f8d7da; border: 1px solid #f5c6cb; border-radius: 8px; padding: 15px; color: #721c24;">
-                <h4 style="margin-top: 0;">❌ Erro na Formatação</h4>
-                <p style="margin: 0;">Erro ao formatar resultado do bot: {str(e)}</p>
-            </div>
-             """
-    
-    @staticmethod
-    def create_header() -> str:
-        """Cria cabeçalho da aplicação."""
-        return f"""
-        <div style="text-align: center; padding: 20px; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); border-radius: 10px; margin-bottom: 20px;">
-            <h1 style="color: white; margin: 0; font-size: 2.5em; text-shadow: 2px 2px 4px rgba(0,0,0,0.3);">
-                📈 {AppConfig.APP_TITLE}
-            </h1>
-            <p style="color: #f0f0f0; margin: 10px 0 0 0; font-size: 1.2em;">
-                {AppConfig.APP_DESCRIPTION}
-            </p>
-        </div>
-        """
-    
-    @staticmethod
-    def create_input_section() -> gr.Column:
-        """Cria seção de entrada de dados."""
-        with gr.Column() as input_section:
-            gr.HTML("""
-            <div style="background: #f8f9fa; padding: 15px; border-radius: 8px; border-left: 4px solid #007bff;">
-                <h3 style="margin: 0 0 10px 0; color: #495057;">📊 Dados de Mercado</h3>
-                <p style="margin: 0; color: #6c757d; font-size: 0.9em;">
-                    Cole os dados do ativo ou digite manualmente os valores
-                </p>
-            </div>
-            """)
-            
-            # Abas para diferentes tipos de entrada
-            with gr.Tabs():
-                with gr.Tab("📊 Análise Manual"):
-                    symbol_input = gr.Textbox(
-                        label="Símbolo do Ativo",
-                        placeholder="Ex: BTCUSDT",
-                        lines=1
-                    )
-                    price_input = gr.Number(
-                        label="Preço Atual",
-                        placeholder="Ex: 45000.50"
-                    )
-                    volume_input = gr.Number(
-                        label="Volume (Opcional)",
-                        placeholder="Ex: 1000000"
-                    )
-                    sentiment_input = gr.Textbox(
-                        label="Texto para Análise de Sentimento (Opcional)",
-                        placeholder="Ex: Notícias ou comentários sobre o ativo",
-                        lines=3
-                    )
-                    analyze_manual_btn = gr.Button(
-                        "🔍 Analisar Manualmente",
-                        variant="primary",
-                        size="lg"
-                    )
-                
-                with gr.Tab("🤖 Log do Bot"):
-                    market_input = gr.Textbox(
-                        label="Log do Bot de Trading",
-                        placeholder=AppConfig.EXAMPLE_INPUT,
-                        lines=8,
-                        max_lines=15
-                    )
-                    analyze_btn = gr.Button(
-                        "🔍 Analisar Log do Bot",
-                        variant="primary",
-                        size="lg"
-                    )
-        
-        return input_section, market_input, analyze_btn, symbol_input, price_input, volume_input, sentiment_input, analyze_manual_btn
-    
-    @staticmethod
-    def create_output_section() -> Tuple[gr.Column, Dict[str, Any]]:
-        """Cria seção de saída de resultados."""
-        outputs = {}
-        
-        with gr.Column() as output_section:
-            # Status do modelo de IA
-            outputs['ai_status'] = gr.HTML(
-                UIComponents._get_ai_status_html(available=False)
-            )
-            
-            # Resultado principal
-            outputs['main_result'] = gr.HTML()
-            
-            # Abas de detalhes
-            with gr.Tabs():
-                # Aba de Análise Técnica
-                with gr.Tab("📊 Análise Técnica"):
-                    outputs['technical_analysis'] = gr.HTML()
-                
-                # Aba de Análise de Sentimento
-                with gr.Tab("🧠 Análise de Sentimento"):
-                    outputs['sentiment_analysis'] = gr.HTML()
-                
-                # Aba de Recomendações
-                with gr.Tab("💡 Recomendações"):
-                    outputs['recommendations'] = gr.HTML()
-                
-                # Aba de Padrões Harmônicos
-                with gr.Tab("🎵 Padrões Harmônicos"):
-                    outputs['harmonic_patterns'] = gr.HTML()
-                
-                # Aba de Alertas Fibonacci
-                with gr.Tab("📐 Fibonacci"):
-                    outputs['fibonacci_alerts'] = gr.HTML()
-                
-                # Aba de Dados Brutos
-                with gr.Tab("🔍 Dados Detalhados"):
-                    outputs['raw_data'] = gr.JSON()
-        
-        # Adicionar novos outputs ao dicionário
-            if 'harmonic_patterns' not in outputs:
-                outputs['harmonic_patterns'] = gr.HTML()
-            if 'fibonacci_alerts' not in outputs:
-                outputs['fibonacci_alerts'] = gr.HTML()
-            
-            return output_section, outputs
-    
-    @staticmethod
-    def create_footer(model_info: Optional[Dict[str, Any]] = None) -> str:
-        """Cria rodapé da aplicação."""
-        timestamp = DateTimeUtils.get_current_datetime()
-        
-        if model_info and model_info.get('available', False):
-            ai_status = f"🤖 IA: {model_info.get('description', 'Modelo Ativo')}"
-        else:
-            ai_status = "⚠️ IA: Indisponível (apenas análise técnica)"
-        
-        return f"""
-        <div style="text-align: center; padding: 15px; background: #f8f9fa; border-radius: 8px; margin-top: 20px; border-top: 2px solid #dee2e6;">
-            <p style="margin: 0; color: #6c757d; font-size: 0.9em;">
-                {ai_status} | ⏰ Última atualização: {timestamp}
-            </p>
-            <p style="margin: 5px 0 0 0; color: #adb5bd; font-size: 0.8em;">
-                Desenvolvido para análise de scalping no mercado financeiro
-            </p>
-        </div>
-        """
-    
-    @staticmethod
-    def _get_ai_status_html(available: bool, model_description: str = "") -> str:
-        """Gera HTML para status da IA."""
-        if available:
-            return f"""
-            <div style="background: #d4edda; border: 1px solid #c3e6cb; border-radius: 8px; padding: 12px; margin-bottom: 15px;">
-                <div style="display: flex; align-items: center; gap: 10px;">
-                    <span style="font-size: 1.2em;">🤖</span>
-                    <div>
-                        <strong style="color: #155724;">IA Ativa:</strong>
-                        <span style="color: #155724;">{model_description}</span>
-                    </div>
-                </div>
-            </div>
-            """
-        else:
-            return """
-            <div style="background: #fff3cd; border: 1px solid #ffeaa7; border-radius: 8px; padding: 12px; margin-bottom: 15px;">
-                <div style="display: flex; align-items: center; gap: 10px;">
-                    <span style="font-size: 1.2em;">⚠️</span>
-                    <div>
-                        <strong style="color: #856404;">IA Indisponível:</strong>
-                        <span style="color: #856404;">Executando apenas análise técnica</span>
-                    </div>
-                </div>
-            </div>
-            """
-
-
-class ResultFormatter:
-    """Formatador de resultados para a interface."""
-    
-    @staticmethod
-    def format_main_result(analysis_result: Dict[str, Any]) -> str:
-        """Formata resultado principal da análise."""
-        action = analysis_result.get('action', 'AGUARDAR')
-        confidence = analysis_result.get('confidence', 0)
-        market_data = analysis_result.get('market_data', {})
-        
-        # Obter informações da ação
-        action_emojis = ActionUtils.get_action_emojis(action)
-        action_color = ActionUtils.get_action_color(action)
-        confidence_level = ConfidenceUtils.get_confidence_level(confidence)
-        confidence_bar = ConfidenceUtils.generate_confidence_bar(confidence)
-        
-        # Formatação do preço
-        price = market_data.get('price', 0)
-        variation = market_data.get('variation', 0)
-        formatted_price = NumberUtils.format_price(price)
-        formatted_variation = NumberUtils.format_percentage(variation)
-        
-        # Cor da variação
-        variation_color = "#28a745" if variation >= 0 else "#dc3545"
-        
-        return f"""
-        <div style="background: linear-gradient(135deg, #f8f9fa 0%, #e9ecef 100%); border-radius: 12px; padding: 25px; margin: 15px 0; border: 2px solid #dee2e6;">
-            <div style="text-align: center; margin-bottom: 20px;">
-                <div style="font-size: 3em; margin-bottom: 10px;">{action_emojis['main']}</div>
-                <h2 style="margin: 0; color: {action_color}; font-size: 2em; text-transform: uppercase; letter-spacing: 1px;">
-                    {action_emojis['action']} {action}
-                </h2>
-            </div>
-            
-            <div style="display: grid; grid-template-columns: 1fr 1fr; gap: 20px; margin-bottom: 20px;">
-                <div style="text-align: center; padding: 15px; background: white; border-radius: 8px; box-shadow: 0 2px 4px rgba(0,0,0,0.1);">
-                    <div style="font-size: 0.9em; color: #6c757d; margin-bottom: 5px;">PREÇO ATUAL</div>
-                    <div style="font-size: 1.8em; font-weight: bold; color: #495057;">{formatted_price}</div>
-                    <div style="font-size: 1.1em; color: {variation_color}; font-weight: 600;">{formatted_variation}</div>
-                </div>
-                
-                <div style="text-align: center; padding: 15px; background: white; border-radius: 8px; box-shadow: 0 2px 4px rgba(0,0,0,0.1);">
-                    <div style="font-size: 0.9em; color: #6c757d; margin-bottom: 5px;">CONFIANÇA</div>
-                    <div style="font-size: 1.8em; font-weight: bold; color: #495057;">{confidence}%</div>
-                    <div style="font-size: 0.9em; color: #6c757d;">{confidence_level}</div>
-                </div>
-            </div>
-            
-            <div style="text-align: center; margin-top: 15px;">
-                <div style="font-size: 0.9em; color: #6c757d; margin-bottom: 8px;">NÍVEL DE CONFIANÇA</div>
-                <div style="font-family: monospace; font-size: 1.2em; letter-spacing: 2px; color: #495057;">{confidence_bar}</div>
-            </div>
-        </div>
-        """
-    
-    @staticmethod
-    def format_technical_analysis(analysis_result: Dict[str, Any]) -> str:
-        """Formata análise técnica."""
-        market_data = analysis_result.get('market_data', {})
-        signals = analysis_result.get('signals', [])
-        
-        # Resumo dos dados de mercado
-        market_summary = FormatUtils.format_market_summary(market_data)
-        
-        # Lista de sinais
-        signals_list = FormatUtils.format_signal_list(signals)
-        
-        return f"""
-        <div style="background: white; border-radius: 8px; padding: 20px; border: 1px solid #dee2e6;">
-            <h3 style="color: #495057; margin-top: 0; border-bottom: 2px solid #007bff; padding-bottom: 10px;">
-                📊 Indicadores Técnicos
-            </h3>
-            
-            <div style="background: #f8f9fa; padding: 15px; border-radius: 6px; margin-bottom: 20px;">
-                {market_summary}
-            </div>
-            
-            <h4 style="color: #495057; margin-bottom: 15px;">🎯 Sinais Detectados</h4>
-            <div style="background: #f8f9fa; padding: 15px; border-radius: 6px; font-family: monospace; white-space: pre-line;">
-                {signals_list}
-            </div>
-        </div>
-        """
-    
-    @staticmethod
-    def format_sentiment_analysis(analysis_result: Dict[str, Any]) -> str:
-        """Formata análise de sentimento."""
-        sentiment = analysis_result.get('sentiment', {})
-        
-        if not sentiment:
-            return """
-            <div style="background: white; border-radius: 8px; padding: 20px; border: 1px solid #dee2e6;">
-                <h3 style="color: #495057; margin-top: 0;">🧠 Análise de Sentimento</h3>
-                <div style="text-align: center; padding: 30px; color: #6c757d;">
-                    <div style="font-size: 2em; margin-bottom: 10px;">⚠️</div>
-                    <p>Análise de sentimento não disponível</p>
-                    <p style="font-size: 0.9em;">Instale as dependências de IA para ativar esta funcionalidade</p>
-                </div>
-            </div>
-            """
-        
-        label = sentiment.get('label', 'NEUTRO')
-        confidence = sentiment.get('confidence', 0)
-        emoji = SentimentUtils.get_sentiment_emoji(label)
-        
-        # Cor baseada no sentimento
-        sentiment_colors = {
-            'POSITIVO': '#28a745',
-            'NEGATIVO': '#dc3545',
-            'NEUTRO': '#ffc107'
-        }
-        color = sentiment_colors.get(label, '#6c757d')
-        
-        return f"""
-        <div style="background: white; border-radius: 8px; padding: 20px; border: 1px solid #dee2e6;">
-            <h3 style="color: #495057; margin-top: 0; border-bottom: 2px solid #28a745; padding-bottom: 10px;">
-                🧠 Análise de Sentimento
-            </h3>
-            
-            <div style="text-align: center; padding: 20px;">
-                <div style="font-size: 3em; margin-bottom: 15px;">{emoji}</div>
-                <h4 style="color: {color}; margin: 0; font-size: 1.5em; text-transform: uppercase;">{label}</h4>
-                <div style="margin-top: 10px; color: #6c757d;">Confiança: {confidence:.1f}%</div>
-            </div>
-            
-            <div style="background: #f8f9fa; padding: 15px; border-radius: 6px; margin-top: 15px;">
-                <h5 style="margin-top: 0; color: #495057;">📝 Detalhes da Análise</h5>
-                <p style="margin: 0; color: #6c757d; font-size: 0.9em;">
-                    O modelo de IA analisou o contexto do mercado e determinou um sentimento <strong>{label.lower()}</strong> 
-                    com {confidence:.1f}% de confiança.
-                </p>
-            </div>
-        </div>
-        """
-    
-    @staticmethod
-    def format_recommendations(analysis_result: Dict[str, Any]) -> str:
-        """Formata recomendações de trading."""
-        action = analysis_result.get('action', 'AGUARDAR')
-        market_data = analysis_result.get('market_data', {})
-        price = market_data.get('price', 0)
-        
-        # Recomendações de trading
-        trading_recs = FormatUtils.format_trading_recommendations(action, price)
-        
-        # Direção de trading
-        direction = ActionUtils.get_trading_direction(action)
-        direction_emoji = "📈" if direction == "COMPRA" else "📉" if direction == "VENDA" else "⏸️"
-        
-        return f"""
-        <div style="background: white; border-radius: 8px; padding: 20px; border: 1px solid #dee2e6;">
-            <h3 style="color: #495057; margin-top: 0; border-bottom: 2px solid #ffc107; padding-bottom: 10px;">
-                💡 Recomendações de Trading
-            </h3>
-            
-            <div style="background: #fff3cd; border: 1px solid #ffeaa7; border-radius: 6px; padding: 15px; margin-bottom: 20px;">
-                <div style="display: flex; align-items: center; gap: 10px; margin-bottom: 10px;">
-                    <span style="font-size: 1.5em;">{direction_emoji}</span>
-                    <strong style="color: #856404;">Direção: {direction}</strong>
-                </div>
-            </div>
-            
-            <div style="background: #f8f9fa; padding: 15px; border-radius: 6px; white-space: pre-line;">
-                {trading_recs}
-            </div>
-            
-            <div style="background: #d1ecf1; border: 1px solid #bee5eb; border-radius: 6px; padding: 15px; margin-top: 15px;">
-                <h5 style="margin-top: 0; color: #0c5460;">⚠️ Aviso Importante</h5>
-                <p style="margin: 0; color: #0c5460; font-size: 0.9em;">
-                    Esta análise é apenas para fins educacionais. Sempre faça sua própria pesquisa e 
-                    considere consultar um consultor financeiro antes de tomar decisões de investimento.
-                </p>
-            </div>
-        </div>
-        """
-
-
-class GradioInterface:
-    """Interface principal do Gradio."""
-    
-    def __init__(self, analysis_function, model_info: Optional[Dict[str, Any]] = None):
-        """Inicializa interface."""
-        self.analysis_function = analysis_function
-        self.model_info = model_info or {'available': False}
-        self.interface = None
-    
-    def analyze_market(self, symbol, price, volume, sentiment_text):
-        """Função principal de análise"""
-        try:
-            # Validar entrada
-            if not symbol or not price:
-                return "❌ Erro: Símbolo e preço são obrigatórios"
-            
-            price = float(price)
-            volume = float(volume) if volume else 0
-            
-            # Criar dados de mercado
-            market_data = {
-                'price': price,
-                'variation': 0,  # Será calculado se necessário
-                'rsi': 50,  # Valor padrão
-                'ema_trend': 'NEUTRO',
-                'bb_position': 'DENTRO',
-                'volume': volume
-            }
-            
-            # Executar análise
-            result = self.analysis_function(f"{symbol}: {price}")
-            
-            # Formatar resultado
-            return self.format_analysis_result(result, sentiment_text, symbol)
-            
-        except Exception as e:
-            return f"❌ Erro na análise: {str(e)}"
-    
-    def analyze_bot_log(self, log_content):
-        """Função para analisar logs do bot externo"""
-        try:
-            if not log_content.strip():
-                return "❌ Erro: Conteúdo do log é obrigatório"
-            
-            # Executar análise do log
-            result = self.analysis_function(log_content)
-            
-            if 'error' in result:
-                return f"❌ {result['error']}"
-            
-            # Formatar resultado específico do bot
-            return self.format_bot_analysis_result(result)
-            
-        except Exception as e:
-            return f"❌ Erro na análise do log: {str(e)}"
-    
-    def format_analysis_result(self, result, sentiment_text, symbol):
-        """Formata resultado da análise"""
-        return ResultFormatter.format_main_result(result)
-    
-    def format_bot_analysis_result(self, result):
-        """Formata resultado específico da análise do bot"""
-        return ResultFormatter.format_main_result(result)
-    
-    def create_interface(self) -> gr.Blocks:
-        """Cria interface completa do Gradio."""
-        with gr.Blocks(
-            title=AppConfig.APP_TITLE,
-            theme=gr.themes.Soft(),
-            css=self._get_custom_css()
-        ) as interface:
-            # Cabeçalho
-            gr.HTML(UIComponents.create_header())
-            
-            # Layout principal
-            with gr.Row():
-                # Coluna de entrada (40%)
-                with gr.Column(scale=2):
-                    input_section, market_input, analyze_btn, symbol_input, price_input, volume_input, sentiment_input, analyze_manual_btn = UIComponents.create_input_section()
-                
-                # Coluna de saída (60%)
-                with gr.Column(scale=3):
-                    output_section, outputs = UIComponents.create_output_section()
-            
-            # Rodapé
-            gr.HTML(UIComponents.create_footer(self.model_info))
-            
-            # Configurar eventos de análise
-            analyze_btn.click(
-                fn=self._analyze_wrapper,
-                inputs=[market_input],
-                outputs=[
-                    outputs['ai_status'],
-                    outputs['main_result'],
-                    outputs['technical_analysis'],
-                    outputs['sentiment_analysis'],
-                    outputs['recommendations'],
-                    outputs['harmonic_patterns'],
-                    outputs['fibonacci_alerts'],
-                    outputs['raw_data']
-                ]
-            )
-            
-            analyze_manual_btn.click(
-                fn=self._analyze_manual_wrapper,
-                inputs=[symbol_input, price_input, volume_input, sentiment_input],
-                outputs=[
-                    outputs['ai_status'],
-                    outputs['main_result'],
-                    outputs['technical_analysis'],
-                    outputs['sentiment_analysis'],
-                    outputs['recommendations'],
-                    outputs['harmonic_patterns'],
-                    outputs['fibonacci_alerts'],
-                    outputs['raw_data']
-                ]
-            )
-            
-            # Atualizar status da IA na inicialização
-            interface.load(
-                fn=lambda: UIComponents._get_ai_status_html(
-                    self.model_info.get('available', False),
-                    self.model_info.get('description', '')
-                ),
-                outputs=[outputs['ai_status']]
-            )
-        
-        self.interface = interface
-        return interface
-    
-    def _analyze_wrapper(self, market_input: str) -> Tuple[str, str, str, str, str, str, str, Dict[str, Any]]:
-        """Wrapper para função de análise com formatação de saída."""
-        try:
-            # Executar análise
-            analysis_result = self.analysis_function(market_input)
-            
-            # Formatear resultados
-            ai_status = UIComponents._get_ai_status_html(
-                self.model_info.get('available', False),
-                self.model_info.get('description', '')
-            )
-            
-            main_result = ResultFormatter.format_main_result(analysis_result)
-            technical_analysis = ResultFormatter.format_technical_analysis(analysis_result)
-            sentiment_analysis = ResultFormatter.format_sentiment_analysis(analysis_result)
-            recommendations = ResultFormatter.format_recommendations(analysis_result)
-            harmonic_patterns = ResultFormatter.format_harmonic_patterns(analysis_result)
-            fibonacci_alerts = ResultFormatter.format_fibonacci_alerts(analysis_result)
-            
-            # Dados brutos para debug
-            raw_data = {
-                'timestamp': DateTimeUtils.get_current_datetime(),
-                'analysis_result': analysis_result
-            }
-            
-            return (
-                ai_status,
-                main_result,
-                technical_analysis,
-                sentiment_analysis,
-                recommendations,
-                harmonic_patterns,
-                fibonacci_alerts,
-                raw_data
-            )
-            
-        except Exception as e:
-            error_msg = f"Erro na análise: {str(e)}"
-            error_html = f"""
-            <div style="background: #f8d7da; border: 1px solid #f5c6cb; border-radius: 8px; padding: 15px; color: #721c24;">
-                <h4 style="margin-top: 0;">❌ Erro na Análise</h4>
-                <p style="margin: 0;">{error_msg}</p>
-            </div>
-            """
-            
-            return (
-                UIComponents._get_ai_status_html(False),
-                error_html,
-                error_html,
-                error_html,
-                error_html,
-                error_html,
-                error_html,
-                {'error': error_msg}
-            )
-    
-    def _analyze_manual_wrapper(self, symbol: str, price: float, volume: float, sentiment_text: str) -> Tuple[str, str, str, str, str, str, str, Dict[str, Any]]:
-        """Wrapper para análise manual com formatação de saída."""
-        try:
-            # Validar entrada
-            if not symbol or not price:
-                raise ValueError("Símbolo e preço são obrigatórios")
-            
-            # Criar entrada formatada
-            market_input = f"{symbol}: Preço={price}, Volume={volume or 0}"
-            if sentiment_text:
-                market_input += f", Sentimento={sentiment_text}"
-            
-            # Executar análise usando o wrapper padrão
-            return self._analyze_wrapper(market_input)
-            
-        except Exception as e:
-            error_msg = f"Erro na análise manual: {str(e)}"
-            error_html = f"""
-            <div style="background: #f8d7da; border: 1px solid #f5c6cb; border-radius: 8px; padding: 15px; color: #721c24;">
-                <h4 style="margin-top: 0;">❌ Erro na Análise Manual</h4>
-                <p style="margin: 0;">{error_msg}</p>
-            </div>
-            """
-            
-            return (
-                UIComponents._get_ai_status_html(False),
-                error_html,
-                error_html,
-                error_html,
-                error_html,
-                error_html,
-                error_html,
-                {'error': error_msg}
-            )
-    
-    def _get_custom_css(self) -> str:
-        """Retorna CSS customizado para a interface."""
-        return """
-        .gradio-container {
-            max-width: 1200px !important;
-            margin: auto !important;
-        }
-        
-        .gr-button {
-            transition: all 0.3s ease !important;
-        }
-        
-        .gr-button:hover {
-            transform: translateY(-2px) !important;
-            box-shadow: 0 4px 8px rgba(0,0,0,0.2) !important;
-        }
-        
-        .gr-textbox textarea {
-            font-family: 'Courier New', monospace !important;
-        }
-        
-        .gr-tab-nav {
-            background: #f8f9fa !important;
-        }
-        
-        .gr-tab-nav button {
-            border-radius: 8px 8px 0 0 !important;
-        }
-        """
-    
-    def launch(self, **kwargs) -> None:
-        """Lança a interface."""
-        if not self.interface:
-            self.create_interface()
-        
-        default_kwargs = {
-            'server_name': '127.0.0.1',
-            'server_port': 7860,
-            'share': False,
-            'show_error': True
-        }
-        
-        # Mesclar argumentos padrão com os fornecidos
-        launch_kwargs = {**default_kwargs, **kwargs}
-        
-        self.interface.launch(**launch_kwargs)

utils.py

@@ -1,330 +0,0 @@
-"""Módulo de utilitários e funções auxiliares."""
-
-import json
-from datetime import datetime
-from typing import Dict, Any, Optional
-
-from config import (
-    TradingConfig,
-    UIConfig,
-    ScoringConfig
-)
-
-
-class DateTimeUtils:
-    """Utilitários para manipulação de data e hora."""
-    
-    @staticmethod
-    def get_current_timestamp() -> str:
-        """Retorna timestamp atual formatado."""
-        return datetime.now().strftime("%H:%M:%S")
-    
-    @staticmethod
-    def get_current_datetime() -> str:
-        """Retorna data e hora atual formatada."""
-        return datetime.now().strftime("%d/%m/%Y %H:%M:%S")
-    
-    @staticmethod
-    def format_timestamp(dt: datetime) -> str:
-        """Formata datetime para timestamp."""
-        return dt.strftime("%H:%M:%S")
-
-
-class NumberUtils:
-    """Utilitários para manipulação de números."""
-    
-    @staticmethod
-    def format_price(price: float) -> str:
-        """Formata preço com separadores de milhares."""
-        return f"{price:,.0f}"
-    
-    @staticmethod
-    def format_percentage(value: float) -> str:
-        """Formata porcentagem com sinal."""
-        return f"{value:+.2f}%"
-    
-    @staticmethod
-    def format_volume(volume: float) -> str:
-        """Formata volume com uma casa decimal."""
-        return f"{volume:.1f}x"
-    
-    @staticmethod
-    def calculate_points_from_percentage(price: float, percentage: float) -> float:
-        """Calcula pontos baseado em porcentagem do preço."""
-        return price * (percentage / 100)
-
-
-class ConfidenceUtils:
-    """Utilitários para manipulação de níveis de confiança."""
-    
-    @staticmethod
-    def get_confidence_level(confidence: int) -> str:
-        """Retorna nível de confiança textual."""
-        config = TradingConfig.CONFIDENCE_LEVELS
-        
-        if confidence >= config['MUITO_ALTA']:
-            return "MUITO ALTA"
-        elif confidence >= config['ALTA']:
-            return "ALTA"
-        elif confidence >= config['MODERADA']:
-            return "MODERADA"
-        else:
-            return "BAIXA"
-    
-    @staticmethod
-    def generate_confidence_bar(confidence: int) -> str:
-        """Gera barra visual de confiança."""
-        filled_bars = int(confidence / 10)
-        empty_bars = 10 - filled_bars
-        return "█" * filled_bars + "░" * empty_bars
-    
-    @staticmethod
-    def is_high_confidence(confidence: int) -> bool:
-        """Verifica se confiança é alta."""
-        return confidence >= TradingConfig.CONFIDENCE_LEVELS['ALTA']
-
-
-class ActionUtils:
-    """Utilitários para manipulação de ações de trading."""
-    
-    @staticmethod
-    def get_action_emojis(action: str) -> Dict[str, str]:
-        """Retorna emojis para ação específica."""
-        return UIConfig.ACTION_EMOJIS.get(action, {
-            'main': '⚪',
-            'action': '❓'
-        })
-    
-    @staticmethod
-    def get_action_color(action: str) -> str:
-        """Retorna cor para ação específica."""
-        return UIConfig.ACTION_COLORS.get(action, 'cinza')
-    
-    @staticmethod
-    def get_trading_direction(action: str) -> str:
-        """Retorna direção de trading para ação."""
-        return UIConfig.TRADING_DIRECTIONS.get(action, 'INDEFINIDO')
-
-
-class SentimentUtils:
-    """Utilitários para manipulação de sentimento."""
-    
-    @staticmethod
-    def get_sentiment_emoji(sentiment_label: str) -> str:
-        """Retorna emoji para sentimento."""
-        return UIConfig.SENTIMENT_EMOJIS.get(sentiment_label, '😐💛')
-    
-    @staticmethod
-    def normalize_sentiment_label(label: str) -> str:
-        """Normaliza label de sentimento."""
-        label_upper = label.upper()
-        valid_labels = ['POSITIVO', 'NEGATIVO', 'NEUTRO']
-        
-        if label_upper in valid_labels:
-            return label_upper
-        
-        # Mapeamento de labels alternativos
-        label_mapping = {
-            'POSITIVE': 'POSITIVO',
-            'NEGATIVE': 'NEGATIVO',
-            'NEUTRAL': 'NEUTRO',
-            'POS': 'POSITIVO',
-            'NEG': 'NEGATIVO',
-            'NEU': 'NEUTRO'
-        }
-        
-        return label_mapping.get(label_upper, 'NEUTRO')
-
-
-class ValidationUtils:
-    """Utilitários para validação de dados."""
-    
-    @staticmethod
-    def validate_market_data(data: Dict[str, Any]) -> bool:
-        """Valida dados de mercado."""
-        required_fields = ['price', 'variation', 'rsi', 'ema_trend', 'bb_position', 'volume']
-        
-        # Verificar se todos os campos obrigatórios estão presentes
-        for field in required_fields:
-            if field not in data:
-                return False
-        
-        # Validar tipos e valores
-        try:
-            price = float(data['price'])
-            variation = float(data['variation'])
-            rsi = int(data['rsi'])
-            volume = float(data['volume'])
-            
-            # Validar ranges
-            if price < 0 or not (0 <= rsi <= 100) or volume < 0:
-                return False
-            
-            # Validar strings
-            valid_ema_trends = ['ALTA', 'BAIXA', 'NEUTRO']
-            valid_bb_positions = ['DENTRO', 'SOBRE', 'ABAIXO', 'ACIMA']
-            
-            if (data['ema_trend'] not in valid_ema_trends or 
-                data['bb_position'] not in valid_bb_positions):
-                return False
-            
-            return True
-            
-        except (ValueError, TypeError):
-            return False
-    
-    @staticmethod
-    def validate_confidence_score(score: int) -> int:
-        """Valida e normaliza pontuação de confiança."""
-        return max(ScoringConfig.MIN_CONFIDENCE, 
-                  min(ScoringConfig.MAX_CONFIDENCE, score))
-    
-    @staticmethod
-    def validate_text_input(text: str) -> bool:
-        """Valida entrada de texto."""
-        if not text or not isinstance(text, str):
-            return False
-        
-        # Verificar se não é apenas espaços em branco
-        if not text.strip():
-            return False
-        
-        # Verificar tamanho mínimo
-        if len(text.strip()) < 3:
-            return False
-        
-        return True
-
-
-class FormatUtils:
-    """Utilitários para formatação de texto e dados."""
-    
-    @staticmethod
-    def format_signal_list(signals: list) -> str:
-        """Formata lista de sinais para exibição."""
-        if not signals:
-            return "Nenhum sinal detectado"
-        
-        formatted_signals = []
-        for i, signal in enumerate(signals[:5], 1):  # Máximo 5 sinais
-            if hasattr(signal, 'description'):
-                formatted_signals.append(f"{i}. {signal.description}")
-            else:
-                formatted_signals.append(f"{i}. {str(signal)}")
-        
-        return "\n".join(formatted_signals)
-    
-    @staticmethod
-    def format_market_summary(market_data: Dict[str, Any]) -> str:
-        """Formata resumo dos dados de mercado."""
-        price = NumberUtils.format_price(market_data.get('price', 0))
-        variation = NumberUtils.format_percentage(market_data.get('variation', 0))
-        volume = NumberUtils.format_volume(market_data.get('volume', 0))
-        
-        return f"""• **Preço:** {price}
-• **Variação:** {variation}
-• **RSI:** {market_data.get('rsi', 'N/A')} 
-• **EMA:** {market_data.get('ema_trend', 'N/A')}
-• **Bollinger:** {market_data.get('bb_position', 'N/A')}
-• **Volume:** {volume}"""
-    
-    @staticmethod
-    def format_trading_recommendations(action: str, price: float) -> str:
-        """Formata recomendações de trading."""
-        if action == 'COMPRAR':
-            stop_loss = price * (1 - TradingConfig.STOP_LOSS_PERCENTAGE)
-            take_profit = price * (1 + TradingConfig.TAKE_PROFIT_PERCENTAGE)
-            
-            return f"""• **Stop Loss:** -{NumberUtils.calculate_points_from_percentage(price, TradingConfig.STOP_LOSS_PERCENTAGE * 100):.0f} pts ({TradingConfig.STOP_LOSS_PERCENTAGE * 100:.2f}%)
-• **Take Profit:** +{NumberUtils.calculate_points_from_percentage(price, TradingConfig.TAKE_PROFIT_PERCENTAGE * 100):.0f} pts ({TradingConfig.TAKE_PROFIT_PERCENTAGE * 100:.2f}%)
-• **Timeframe:** {'/'.join(TradingConfig.SCALPING_TIMEFRAMES)}
-• **Risk/Reward:** 1:{TradingConfig.RISK_REWARD_RATIO}"""
-        
-        elif action == 'VENDER':
-            stop_loss = price * (1 + TradingConfig.STOP_LOSS_PERCENTAGE)
-            take_profit = price * (1 - TradingConfig.TAKE_PROFIT_PERCENTAGE)
-            
-            return f"""• **Stop Loss:** +{NumberUtils.calculate_points_from_percentage(price, TradingConfig.STOP_LOSS_PERCENTAGE * 100):.0f} pts ({TradingConfig.STOP_LOSS_PERCENTAGE * 100:.2f}%)
-• **Take Profit:** -{NumberUtils.calculate_points_from_percentage(price, TradingConfig.TAKE_PROFIT_PERCENTAGE * 100):.0f} pts ({TradingConfig.TAKE_PROFIT_PERCENTAGE * 100:.2f}%)
-• **Timeframe:** {'/'.join(TradingConfig.SCALPING_TIMEFRAMES)}
-• **Risk/Reward:** 1:{TradingConfig.RISK_REWARD_RATIO}"""
-        
-        else:
-            return """• **Aguardar:** Setup mais definido
-• **Monitorar:** Rompimentos de suporte/resistência
-• **Observar:** Confluência de sinais técnicos"""
-
-
-class LogUtils:
-    """Utilitários para logging e debug."""
-    
-    @staticmethod
-    def log_analysis_result(analysis_result: Dict[str, Any]) -> None:
-        """Registra resultado de análise para debug."""
-        timestamp = DateTimeUtils.get_current_datetime()
-        action = analysis_result.get('action', 'UNKNOWN')
-        confidence = analysis_result.get('confidence', 0)
-        
-        print(f"[{timestamp}] Análise: {action} (Confiança: {confidence}%)")
-    
-    @staticmethod
-    def log_error(error_message: str, context: str = "") -> None:
-        """Registra erro com contexto."""
-        timestamp = DateTimeUtils.get_current_datetime()
-        context_str = f" [{context}]" if context else ""
-        print(f"[{timestamp}] ERRO{context_str}: {error_message}")
-    
-    @staticmethod
-    def log_model_status(model_info: Dict[str, Any]) -> None:
-        """Registra status do modelo de IA."""
-        timestamp = DateTimeUtils.get_current_datetime()
-        status = "ATIVO" if model_info.get('available', False) else "INATIVO"
-        model_name = model_info.get('description', 'Desconhecido')
-        
-        print(f"[{timestamp}] Modelo IA: {status} - {model_name}")
-
-
-class DataExportUtils:
-    """Utilitários para exportação de dados."""
-    
-    @staticmethod
-    def export_analysis_to_json(analysis_result: Dict[str, Any]) -> str:
-        """Exporta resultado de análise para JSON."""
-        # Preparar dados para serialização
-        export_data = {
-            'timestamp': DateTimeUtils.get_current_datetime(),
-            'action': analysis_result.get('action'),
-            'confidence': analysis_result.get('confidence'),
-            'market_data': analysis_result.get('market_data'),
-            'sentiment': analysis_result.get('sentiment')
-        }
-        
-        # Converter objetos complexos para dicionários
-        if 'signals' in analysis_result:
-            export_data['signals'] = [
-                {
-                    'indicator': getattr(signal, 'indicator', 'unknown'),
-                    'signal_type': getattr(signal, 'signal_type', 'unknown'),
-                    'strength': getattr(signal, 'strength', 0),
-                    'description': getattr(signal, 'description', '')
-                }
-                for signal in analysis_result['signals']
-            ]
-        
-        return json.dumps(export_data, indent=2, ensure_ascii=False)
-    
-    @staticmethod
-    def create_analysis_summary(analysis_result: Dict[str, Any]) -> Dict[str, Any]:
-        """Cria resumo da análise para relatórios."""
-        return {
-            'timestamp': DateTimeUtils.get_current_datetime(),
-            'action': analysis_result.get('action', 'UNKNOWN'),
-            'confidence': analysis_result.get('confidence', 0),
-            'confidence_level': ConfidenceUtils.get_confidence_level(
-                analysis_result.get('confidence', 0)
-            ),
-            'signals_count': len(analysis_result.get('signals', [])),
-            'sentiment_label': analysis_result.get('sentiment', {}).get('label', 'NEUTRO'),
-            'market_price': analysis_result.get('market_data', {}).get('price', 0),
-            'market_rsi': analysis_result.get('market_data', {}).get('rsi', 50)
-        }