Initial commit: Complete Fibonacci analysis application with Gradio interface

__init__.py

@@ -0,0 +1 @@
+# Arquivo __init__.py para tornar o diretório raiz um pacote Python

advanced_market_processing.py

@@ -0,0 +1,466 @@
+import numpy as np
+import pandas as pd
+from typing import Dict, List, Optional, Tuple, Any
+from dataclasses import dataclass
+import logging
+from datetime import datetime
+
+# Configurar logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+@dataclass
+class SwingPoint:
+    """Representa um ponto de swing no mercado"""
+    price: float
+    timestamp: datetime
+    type: str  # 'high' ou 'low'
+    strength: float  # 0-1, força do swing
+    volume: Optional[float] = None
+
+@dataclass
+class ConfluenceZone:
+    """Representa uma zona de confluência"""
+    price_level: float
+    strength: float  # 0-1
+    factors: List[str]  # Fatores que contribuem para a confluência
+    type: str  # 'support' ou 'resistance'
+    reliability: float  # 0-1
+
+@dataclass
+class HarmonicPattern:
+    """Representa um padrão harmônico"""
+    name: str  # 'Gartley', 'Butterfly', 'Bat', 'Crab'
+    points: Dict[str, SwingPoint]  # X, A, B, C, D
+    completion_level: float
+    target_levels: List[float]
+    stop_level: float
+    reliability: float  # 0-1
+
+class SwingPointDetector:
+    """Detector de pontos de swing"""
+    
+    def __init__(self, lookback_period: int = 5, min_strength: float = 0.3):
+        self.lookback_period = lookback_period
+        self.min_strength = min_strength
+    
+    def detect_swing_points(self, prices: np.ndarray, volumes: Optional[np.ndarray] = None) -> List[SwingPoint]:
+        """Detecta pontos de swing em uma série de preços"""
+        try:
+            swing_points = []
+            
+            for i in range(self.lookback_period, len(prices) - self.lookback_period):
+                # Verificar swing high
+                if self._is_swing_high(prices, i):
+                    strength = self._calculate_swing_strength(prices, i, 'high')
+                    if strength >= self.min_strength:
+                        swing_points.append(SwingPoint(
+                            price=prices[i],
+                            timestamp=datetime.now(),
+                            type='high',
+                            strength=strength,
+                            volume=volumes[i] if volumes is not None else None
+                        ))
+                
+                # Verificar swing low
+                elif self._is_swing_low(prices, i):
+                    strength = self._calculate_swing_strength(prices, i, 'low')
+                    if strength >= self.min_strength:
+                        swing_points.append(SwingPoint(
+                            price=prices[i],
+                            timestamp=datetime.now(),
+                            type='low',
+                            strength=strength,
+                            volume=volumes[i] if volumes is not None else None
+                        ))
+            
+            return swing_points
+            
+        except Exception as e:
+            logger.error(f"Erro ao detectar swing points: {e}")
+            return []
+    
+    def _is_swing_high(self, prices: np.ndarray, index: int) -> bool:
+        """Verifica se um ponto é um swing high"""
+        current_price = prices[index]
+        left_prices = prices[index - self.lookback_period:index]
+        right_prices = prices[index + 1:index + self.lookback_period + 1]
+        
+        return (current_price > np.max(left_prices) and 
+                current_price > np.max(right_prices))
+    
+    def _is_swing_low(self, prices: np.ndarray, index: int) -> bool:
+        """Verifica se um ponto é um swing low"""
+        current_price = prices[index]
+        left_prices = prices[index - self.lookback_period:index]
+        right_prices = prices[index + 1:index + self.lookback_period + 1]
+        
+        return (current_price < np.min(left_prices) and 
+                current_price < np.min(right_prices))
+    
+    def _calculate_swing_strength(self, prices: np.ndarray, index: int, swing_type: str) -> float:
+        """Calcula a força de um swing point"""
+        try:
+            current_price = prices[index]
+            surrounding_prices = np.concatenate([
+                prices[max(0, index - self.lookback_period * 2):index],
+                prices[index + 1:min(len(prices), index + self.lookback_period * 2 + 1)]
+            ])
+            
+            if swing_type == 'high':
+                price_diff = current_price - np.mean(surrounding_prices)
+                max_diff = np.max(surrounding_prices) - np.min(surrounding_prices)
+            else:
+                price_diff = np.mean(surrounding_prices) - current_price
+                max_diff = np.max(surrounding_prices) - np.min(surrounding_prices)
+            
+            return min(1.0, max(0.0, price_diff / max_diff)) if max_diff > 0 else 0.0
+            
+        except Exception:
+            return 0.0
+
+class ConfluenceZoneAnalyzer:
+    """Analisador de zonas de confluência"""
+    
+    def __init__(self, tolerance: float = 0.001):
+        self.tolerance = tolerance  # Tolerância para agrupar níveis próximos
+    
+    def analyze_confluence_zones(self, 
+                               swing_points: List[SwingPoint],
+                               fibonacci_levels: Dict[str, float],
+                               support_resistance_levels: List[float]) -> List[ConfluenceZone]:
+        """Analisa zonas de confluência baseado em múltiplos fatores"""
+        try:
+            confluence_zones = []
+            all_levels = []
+            
+            # Coletar todos os níveis relevantes
+            for swing in swing_points:
+                all_levels.append(('swing', swing.price, swing.strength))
+            
+            for fib_name, fib_level in fibonacci_levels.items():
+                all_levels.append(('fibonacci', fib_level, 0.7))
+            
+            for sr_level in support_resistance_levels:
+                all_levels.append(('support_resistance', sr_level, 0.8))
+            
+            # Agrupar níveis próximos
+            grouped_levels = self._group_nearby_levels(all_levels)
+            
+            # Criar zonas de confluência
+            for group in grouped_levels:
+                if len(group) >= 2:  # Pelo menos 2 fatores para confluência
+                    avg_price = np.mean([level[1] for level in group])
+                    factors = [level[0] for level in group]
+                    strength = np.mean([level[2] for level in group])
+                    
+                    # Determinar tipo (support/resistance)
+                    zone_type = self._determine_zone_type(group, swing_points)
+                    
+                    confluence_zones.append(ConfluenceZone(
+                        price_level=avg_price,
+                        strength=strength,
+                        factors=factors,
+                        type=zone_type,
+                        reliability=min(1.0, len(group) * 0.3)
+                    ))
+            
+            return sorted(confluence_zones, key=lambda x: x.strength, reverse=True)
+            
+        except Exception as e:
+            logger.error(f"Erro ao analisar zonas de confluência: {e}")
+            return []
+    
+    def _group_nearby_levels(self, levels: List[Tuple]) -> List[List[Tuple]]:
+        """Agrupa níveis próximos baseado na tolerância"""
+        if not levels:
+            return []
+        
+        sorted_levels = sorted(levels, key=lambda x: x[1])
+        groups = []
+        current_group = [sorted_levels[0]]
+        
+        for level in sorted_levels[1:]:
+            if abs(level[1] - current_group[-1][1]) / current_group[-1][1] <= self.tolerance:
+                current_group.append(level)
+            else:
+                groups.append(current_group)
+                current_group = [level]
+        
+        groups.append(current_group)
+        return groups
+    
+    def _determine_zone_type(self, group: List[Tuple], swing_points: List[SwingPoint]) -> str:
+        """Determina se a zona é de suporte ou resistência"""
+        # Lógica simplificada - pode ser melhorada
+        swing_highs = [s for s in swing_points if s.type == 'high']
+        swing_lows = [s for s in swing_points if s.type == 'low']
+        
+        avg_price = np.mean([level[1] for level in group])
+        
+        if swing_lows:
+            avg_low = np.mean([s.price for s in swing_lows])
+            if abs(avg_price - avg_low) < abs(avg_price - np.mean([s.price for s in swing_highs]) if swing_highs else avg_price):
+                return 'support'
+        
+        return 'resistance'
+
+class HarmonicPatternDetector:
+    """Detector de padrões harmônicos"""
+    
+    def __init__(self):
+        self.pattern_ratios = {
+            'Gartley': {
+                'XA_AB': (0.618, 0.618),
+                'AB_BC': (0.382, 0.886),
+                'BC_CD': (1.13, 1.618),
+                'XA_AD': (0.786, 0.786)
+            },
+            'Butterfly': {
+                'XA_AB': (0.786, 0.786),
+                'AB_BC': (0.382, 0.886),
+                'BC_CD': (1.618, 2.618),
+                'XA_AD': (1.27, 1.618)
+            },
+            'Bat': {
+                'XA_AB': (0.382, 0.5),
+                'AB_BC': (0.382, 0.886),
+                'BC_CD': (1.618, 2.618),
+                'XA_AD': (0.886, 0.886)
+            },
+            'Crab': {
+                'XA_AB': (0.382, 0.618),
+                'AB_BC': (0.382, 0.886),
+                'BC_CD': (2.24, 3.618),
+                'XA_AD': (1.618, 1.618)
+            }
+        }
+    
+    def detect_harmonic_patterns(self, swing_points: List[SwingPoint]) -> List[HarmonicPattern]:
+        """Detecta padrões harmônicos nos swing points"""
+        try:
+            patterns = []
+            
+            if len(swing_points) < 5:
+                return patterns
+            
+            # Procurar por sequências de 5 pontos (X, A, B, C, D)
+            for i in range(len(swing_points) - 4):
+                points = swing_points[i:i+5]
+                
+                # Verificar se a sequência alterna entre high/low
+                if self._is_valid_sequence(points):
+                    for pattern_name, ratios in self.pattern_ratios.items():
+                        pattern = self._check_pattern(points, pattern_name, ratios)
+                        if pattern:
+                            patterns.append(pattern)
+            
+            return patterns
+            
+        except Exception as e:
+            logger.error(f"Erro ao detectar padrões harmônicos: {e}")
+            return []
+    
+    def _is_valid_sequence(self, points: List[SwingPoint]) -> bool:
+        """Verifica se a sequência de pontos é válida para padrões harmônicos"""
+        types = [p.type for p in points]
+        
+        # Deve alternar entre high e low
+        for i in range(1, len(types)):
+            if types[i] == types[i-1]:
+                return False
+        
+        return True
+    
+    def _check_pattern(self, points: List[SwingPoint], pattern_name: str, ratios: Dict) -> Optional[HarmonicPattern]:
+        """Verifica se os pontos formam um padrão harmônico específico"""
+        try:
+            X, A, B, C, D = points
+            
+            # Calcular distâncias
+            XA = abs(A.price - X.price)
+            AB = abs(B.price - A.price)
+            BC = abs(C.price - B.price)
+            CD = abs(D.price - C.price)
+            XD = abs(D.price - X.price)
+            
+            # Verificar ratios
+            tolerance = 0.05  # 5% de tolerância
+            
+            ratios_to_check = [
+                ('XA_AB', AB / XA if XA != 0 else 0),
+                ('AB_BC', BC / AB if AB != 0 else 0),
+                ('BC_CD', CD / BC if BC != 0 else 0),
+                ('XA_AD', XD / XA if XA != 0 else 0)
+            ]
+            
+            valid_ratios = 0
+            for ratio_name, calculated_ratio in ratios_to_check:
+                expected_min, expected_max = ratios[ratio_name]
+                if expected_min * (1 - tolerance) <= calculated_ratio <= expected_max * (1 + tolerance):
+                    valid_ratios += 1
+            
+            # Padrão válido se pelo menos 3 dos 4 ratios estiverem corretos
+            if valid_ratios >= 3:
+                # Calcular níveis de target e stop
+                target_levels = self._calculate_targets(X, A, B, C, D)
+                stop_level = self._calculate_stop_level(X, A, B, C, D)
+                
+                return HarmonicPattern(
+                    name=pattern_name,
+                    points={'X': X, 'A': A, 'B': B, 'C': C, 'D': D},
+                    completion_level=D.price,
+                    target_levels=target_levels,
+                    stop_level=stop_level,
+                    reliability=valid_ratios / 4.0
+                )
+            
+            return None
+            
+        except Exception as e:
+            logger.error(f"Erro ao verificar padrão {pattern_name}: {e}")
+            return None
+    
+    def _calculate_targets(self, X, A, B, C, D) -> List[float]:
+        """Calcula níveis de target para o padrão"""
+        try:
+            XA = abs(A.price - X.price)
+            
+            # Targets baseados em retracements de Fibonacci
+            if D.type == 'low':  # Padrão bullish
+                target1 = D.price + (XA * 0.382)
+                target2 = D.price + (XA * 0.618)
+                target3 = D.price + XA
+            else:  # Padrão bearish
+                target1 = D.price - (XA * 0.382)
+                target2 = D.price - (XA * 0.618)
+                target3 = D.price - XA
+            
+            return [target1, target2, target3]
+            
+        except Exception:
+            return [D.price]
+    
+    def _calculate_stop_level(self, X, A, B, C, D) -> float:
+        """Calcula nível de stop loss para o padrão"""
+        try:
+            # Stop além do ponto D
+            if D.type == 'low':  # Padrão bullish
+                return D.price * 0.99  # 1% abaixo
+            else:  # Padrão bearish
+                return D.price * 1.01  # 1% acima
+        except Exception:
+            return D.price
+
+class AdvancedMarketProcessor:
+    """Processador avançado de dados de mercado"""
+    
+    def __init__(self):
+        self.swing_detector = SwingPointDetector()
+        self.confluence_analyzer = ConfluenceZoneAnalyzer()
+        self.harmonic_detector = HarmonicPatternDetector()
+        logger.info("AdvancedMarketProcessor inicializado")
+    
+    def process_market_data(self, 
+                          prices: np.ndarray, 
+                          volumes: Optional[np.ndarray] = None,
+                          fibonacci_levels: Optional[Dict[str, float]] = None,
+                          support_resistance_levels: Optional[List[float]] = None) -> Dict[str, Any]:
+        """Processa dados de mercado com análise avançada"""
+        try:
+            # Detectar swing points
+            swing_points = self.swing_detector.detect_swing_points(prices, volumes)
+            
+            # Analisar zonas de confluência
+            confluence_zones = []
+            if fibonacci_levels or support_resistance_levels:
+                confluence_zones = self.confluence_analyzer.analyze_confluence_zones(
+                    swing_points,
+                    fibonacci_levels or {},
+                    support_resistance_levels or []
+                )
+            
+            # Detectar padrões harmônicos
+            harmonic_patterns = self.harmonic_detector.detect_harmonic_patterns(swing_points)
+            
+            # Compilar resultado
+            result = {
+                'swing_points': {
+                    'count': len(swing_points),
+                    'highs': [sp for sp in swing_points if sp.type == 'high'],
+                    'lows': [sp for sp in swing_points if sp.type == 'low'],
+                    'avg_strength': np.mean([sp.strength for sp in swing_points]) if swing_points else 0
+                },
+                'confluence_zones': {
+                    'count': len(confluence_zones),
+                    'zones': confluence_zones,
+                    'strongest_zone': max(confluence_zones, key=lambda x: x.strength) if confluence_zones else None
+                },
+                'harmonic_patterns': {
+                    'count': len(harmonic_patterns),
+                    'patterns': harmonic_patterns,
+                    'most_reliable': max(harmonic_patterns, key=lambda x: x.reliability) if harmonic_patterns else None
+                },
+                'market_structure': self._analyze_market_structure(swing_points),
+                'key_levels': self._identify_key_levels(swing_points, confluence_zones)
+            }
+            
+            return result
+            
+        except Exception as e:
+            logger.error(f"Erro no processamento avançado de mercado: {e}")
+            return {
+                'swing_points': {'count': 0, 'highs': [], 'lows': [], 'avg_strength': 0},
+                'confluence_zones': {'count': 0, 'zones': [], 'strongest_zone': None},
+                'harmonic_patterns': {'count': 0, 'patterns': [], 'most_reliable': None},
+                'market_structure': 'UNKNOWN',
+                'key_levels': []
+            }
+    
+    def _analyze_market_structure(self, swing_points: List[SwingPoint]) -> str:
+        """Analisa a estrutura do mercado baseado nos swing points"""
+        try:
+            if len(swing_points) < 4:
+                return 'INSUFFICIENT_DATA'
+            
+            recent_points = swing_points[-4:]
+            highs = [sp for sp in recent_points if sp.type == 'high']
+            lows = [sp for sp in recent_points if sp.type == 'low']
+            
+            if len(highs) >= 2 and len(lows) >= 2:
+                # Verificar tendência dos highs e lows
+                high_trend = 'UP' if highs[-1].price > highs[0].price else 'DOWN'
+                low_trend = 'UP' if lows[-1].price > lows[0].price else 'DOWN'
+                
+                if high_trend == 'UP' and low_trend == 'UP':
+                    return 'UPTREND'
+                elif high_trend == 'DOWN' and low_trend == 'DOWN':
+                    return 'DOWNTREND'
+                else:
+                    return 'SIDEWAYS'
+            
+            return 'CONSOLIDATION'
+            
+        except Exception:
+            return 'UNKNOWN'
+    
+    def _identify_key_levels(self, swing_points: List[SwingPoint], confluence_zones: List[ConfluenceZone]) -> List[float]:
+        """Identifica níveis-chave baseado em swing points e confluências"""
+        try:
+            key_levels = []
+            
+            # Adicionar swing points mais fortes
+            strong_swings = [sp for sp in swing_points if sp.strength > 0.7]
+            key_levels.extend([sp.price for sp in strong_swings])
+            
+            # Adicionar zonas de confluência mais fortes
+            strong_zones = [cz for cz in confluence_zones if cz.strength > 0.6]
+            key_levels.extend([cz.price_level for cz in strong_zones])
+            
+            # Remover duplicatas e ordenar
+            key_levels = sorted(list(set(key_levels)))
+            
+            return key_levels[:10]  # Retornar apenas os 10 mais importantes
+            
+        except Exception:
+            return []

app.py

@@ -6,11 +6,15 @@ from datetime import datetime
 
 # Importar módulos refatorados
 try:
-    from config import AppConfig
-    from market_analysis import TechnicalAnalysisEngine
-    from sentiment_analysis import SentimentAnalysisEngine
-    from ui import GradioInterface
-    from utils import LogUtils, ValidationUtils
+    from config.config import AppConfig
+    from src.analysis.market_analysis import TechnicalAnalysisEngine
+    from src.analysis.sentiment_analysis import SentimentAnalysisEngine
+    from src.ui.gradio_interface import GradioInterface
+    from src.utils.utils import LogUtils, ValidationUtils
+    from src.core.log_parser import VampireBotLogParser
+    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
 except ImportError:
     # Fallback para modo standalone se módulos não existirem
     print("⚠️ Módulos refatorados não encontrados. Executando em modo standalone.")
@@ -20,12 +24,27 @@ except ImportError:
     GradioInterface = None
     LogUtils = None
     ValidationUtils = None
+    VampireBotLogParser = None
+    AdvancedFibonacciEngine = None
+    AdvancedMarketProcessor = None
+    RealTimeIntegration = None
+    BotEvent = None
+    PerformanceMonitor = None
+    measure_analysis_time = None
 
 # Engines de análise
 technical_engine = None
 sentiment_engine = None
+real_time_integration = None
 model_info = {'available': False, 'description': 'IA Indisponível'}
 
+# Estado global para eventos em tempo real
+recent_events = []
+max_events_display = 50
+
+# Monitor de performance global
+performance_monitor = PerformanceMonitor() if PerformanceMonitor else None
+
 # Inicializar engines
 def initialize_engines():
     """Inicializa engines de análise técnica e de sentimento."""
@@ -483,6 +502,15 @@ def process_trading_analysis(text):
             return "⚠️ **Erro:** Nenhum dado de mercado fornecido para análise."
     
     try:
+        # Verificar se é um log do bot
+        if 'VAMPIRE TRADING BOT' in text or 'FIBONACCI AVANÇADO' in text:
+            if VampireBotLogParser:
+                log_parser = VampireBotLogParser()
+                return log_parser.process_bot_log(text)
+            else:
+                # Fallback para processamento de log
+                return process_bot_log_fallback(text)
+        
         # Parse dos dados de mercado
         market_data = parse_market_data(text)
         
@@ -506,6 +534,50 @@ def process_trading_analysis(text):
         
         return f"❌ **Erro:** {error_msg}"
 
+def process_bot_log_fallback(text):
+    """Processamento fallback para logs do bot quando VampireBotLogParser não está disponível."""
+    try:
+        # Extrair informações básicas do log
+        import re
+        
+        # Buscar por padrões específicos do bot
+        fibonacci_match = re.search(r'FIBONACCI AVANÇADO.*?Nível: ([\d.]+)', text, re.DOTALL)
+        action_match = re.search(r'(COMPRAR|VENDER|AGUARDAR)', text)
+        confidence_match = re.search(r'Confiança: (\d+)%', text)
+        
+        if fibonacci_match or action_match:
+            response = "🤖 **ANÁLISE DE LOG DO BOT DETECTADA**\n\n"
+            
+            if action_match:
+                action = action_match.group(1)
+                response += f"**Ação Recomendada:** {action}\n"
+            
+            if confidence_match:
+                confidence = confidence_match.group(1)
+                response += f"**Confiança:** {confidence}%\n"
+            
+            if fibonacci_match:
+                fib_level = fibonacci_match.group(1)
+                response += f"**Nível Fibonacci:** {fib_level}\n"
+            
+            response += "\n⚠️ **Nota:** Processamento básico de log. Para análise completa, instale os módulos avançados."
+            return response
+        
+        # Se não conseguir extrair dados do log, processar como entrada normal
+        return process_trading_analysis_basic(text)
+        
+    except Exception as e:
+        return f"❌ **Erro no processamento do log:** {str(e)}"
+
+def process_trading_analysis_basic(text):
+    """Processamento básico quando não há log do bot."""
+    market_data = parse_market_data(text)
+    if not market_data:
+        return "⚠️ **Erro:** Não foi possível extrair dados válidos do texto fornecido."
+    
+    analysis = analyze_scalping_signals(market_data, text)
+    return generate_trading_response(analysis)
+
 # Função principal de análise para a interface
 def main_analysis_function(text: str) -> str:
     """Função principal de análise que será usada pela interface."""
@@ -552,26 +624,504 @@ Notícias: Mercado otimista com dados do PIB"""
         </div>
         """)
         
-        with gr.Row():
-            with gr.Column(scale=2):
-                market_input = gr.Textbox(
-                    label="Dados do Mercado",
-                    placeholder=example_data,
-                    lines=8
-                )
-                analyze_btn = gr.Button("🔍 Analisar", variant="primary")
-            
-            with gr.Column(scale=3):
-                result_output = gr.HTML()
+        with gr.Tab("📊 Análise de Mercado"):
+            with gr.Row():
+                with gr.Column(scale=2):
+                    market_input = gr.Textbox(
+                        label="Dados do Mercado",
+                        placeholder=example_data,
+                        lines=8
+                    )
+                    analyze_btn = gr.Button("🔍 Analisar", variant="primary")
+                
+                with gr.Column(scale=3):
+                    result_output = gr.HTML()
+        
+        with gr.Tab("🤖 Monitor do Bot"):
+             with gr.Row():
+                 with gr.Column(scale=1):
+                     gr.Markdown("### 🔄 Status do Sistema")
+                     
+                     with gr.Row():
+                         start_monitor_btn = gr.Button("▶️ Iniciar Monitor", variant="primary")
+                         stop_monitor_btn = gr.Button("⏹️ Parar Monitor", variant="secondary")
+                     
+                     monitor_status = gr.HTML(
+                         value="<div style='color: #666;'>Monitor parado</div>"
+                     )
+                     
+                     gr.Markdown("### ⚡ Eventos Recentes")
+                     recent_events_display = gr.HTML(
+                         value="<div style='color: #666;'>Nenhum evento recente</div>"
+                     )
+                     
+                 with gr.Column(scale=2):
+                     gr.Markdown("### 📊 Análise em Tempo Real")
+                     real_time_analysis = gr.HTML(
+                         value="<div style='text-align: center; color: #666; padding: 40px;'>Aguardando dados do bot...</div>"
+                     )
+                     
+                     log_file_path = gr.Textbox(
+                         value="d:/hugging_face_spaces/text",
+                         label="📁 Caminho do Arquivo de Log"
+                     )
+                     
+                     check_interval = gr.Slider(
+                         minimum=0.5,
+                         maximum=10.0,
+                         value=1.0,
+                         step=0.5,
+                         label="⏱️ Intervalo de Verificação (segundos)"
+                     )
+        
+        with gr.Tab("📈 Performance"):
+             with gr.Row():
+                 with gr.Column(scale=1):
+                     gr.Markdown("### 🔧 Controles de Performance")
+                     
+                     with gr.Row():
+                         start_perf_btn = gr.Button("▶️ Iniciar Monitoramento", variant="primary")
+                         stop_perf_btn = gr.Button("⏹️ Parar Monitoramento", variant="secondary")
+                     
+                     perf_status = gr.HTML(
+                         value="<div style='color: #666;'>Monitoramento parado</div>"
+                     )
+                     
+                     with gr.Row():
+                         reset_stats_btn = gr.Button("🔄 Reset Estatísticas", variant="secondary")
+                         export_metrics_btn = gr.Button("💾 Exportar Métricas", variant="secondary")
+                     
+                     gr.Markdown("### 🚨 Alertas de Performance")
+                     performance_alerts = gr.HTML(
+                         value="<div style='color: #666;'>Nenhum alerta ativo</div>"
+                     )
+                     
+                 with gr.Column(scale=2):
+                     gr.Markdown("### 📊 Métricas do Sistema")
+                     system_metrics = gr.HTML(
+                         value="<div style='text-align: center; color: #666; padding: 40px;'>Aguardando métricas...</div>"
+                     )
+                     
+                     gr.Markdown("### 🤖 Estatísticas do Bot")
+                     bot_statistics = gr.HTML(
+                         value="<div style='text-align: center; color: #666; padding: 40px;'>Aguardando estatísticas...</div>"
+                     )
+                     
+                     gr.Markdown("### 💡 Sugestões de Otimização")
+                     optimization_suggestions = gr.HTML(
+                         value="<div style='color: #666;'>Execute análises para obter sugestões</div>"
+                     )
         
         analyze_btn.click(
             fn=main_analysis_function,
             inputs=[market_input],
             outputs=[result_output]
         )
+        
+        start_monitor_btn.click(
+            fn=start_real_time_monitor,
+            inputs=[log_file_path, check_interval],
+            outputs=[monitor_status]
+        )
+        
+        stop_monitor_btn.click(
+             fn=stop_real_time_monitor,
+             outputs=[monitor_status]
+         )
+         
+        # Event handlers para performance
+        start_perf_btn.click(
+            fn=start_performance_monitoring,
+            outputs=[perf_status]
+        )
+        
+        stop_perf_btn.click(
+            fn=stop_performance_monitoring,
+            outputs=[perf_status]
+        )
+        
+        reset_stats_btn.click(
+            fn=reset_performance_stats,
+            outputs=[bot_statistics]
+        )
+        
+        export_metrics_btn.click(
+            fn=export_performance_metrics,
+            outputs=[perf_status]
+        )
+        
+        # Auto-refresh para eventos em tempo real
+        interface.load(
+            fn=get_recent_events_display,
+            outputs=[recent_events_display]
+        )
+        
+        interface.load(
+            fn=get_real_time_analysis_display,
+            outputs=[real_time_analysis]
+        )
+         
+        # Auto-refresh para métricas de performance
+        interface.load(
+            fn=get_system_metrics_display,
+            outputs=[system_metrics]
+        )
+        
+        interface.load(
+            fn=get_bot_statistics_display,
+            outputs=[bot_statistics]
+        )
+        
+        interface.load(
+            fn=get_performance_alerts_display,
+            outputs=[performance_alerts]
+        )
+        
+        interface.load(
+            fn=get_optimization_suggestions_display,
+            outputs=[optimization_suggestions]
+        )
     
     return interface
 
+# Funções para integração em tempo real
+def start_real_time_monitor(log_path: str, interval: float):
+    """Inicia o monitor em tempo real."""
+    global real_time_integration, recent_events
+    
+    try:
+        if RealTimeIntegration:
+            real_time_integration = RealTimeIntegration(log_path)
+            real_time_integration.config.check_interval = interval
+            
+            # Callback para capturar eventos
+            def event_handler(event):
+                global recent_events
+                event_dict = {
+                    'timestamp': event.timestamp.strftime('%H:%M:%S'),
+                    'type': event.event_type,
+                    'data': event.data,
+                    'priority': event.priority
+                }
+                recent_events.append(event_dict)
+                
+                # Manter apenas os últimos eventos
+                if len(recent_events) > max_events_display:
+                    recent_events = recent_events[-max_events_display:]
+            
+            real_time_integration.processor.subscribe(event_handler)
+            real_time_integration.start()
+            return "<div style='color: green;'>✅ Monitor iniciado com sucesso</div>"
+        else:
+            return "<div style='color: orange;'>⚠️ Integração em tempo real não disponível</div>"
+    except Exception as e:
+        return f"<div style='color: red;'>❌ Erro ao iniciar monitor: {str(e)}</div>"
+
+def stop_real_time_monitor():
+    """Para o monitor em tempo real."""
+    global real_time_integration
+    
+    try:
+        if real_time_integration:
+            real_time_integration.stop()
+            real_time_integration = None
+            return "<div style='color: orange;'>⏹️ Monitor parado</div>"
+        else:
+            return "<div style='color: #666;'>Monitor já estava parado</div>"
+    except Exception as e:
+        return f"<div style='color: red;'>❌ Erro ao parar monitor: {str(e)}</div>"
+
+def get_recent_events_display():
+    """Obtém display dos eventos recentes."""
+    global recent_events
+    
+    if not recent_events:
+        return "<div style='color: #666;'>Nenhum evento recente</div>"
+    
+    html = "<div style='max-height: 300px; overflow-y: auto;'>"
+    for event in recent_events[-10:]:  # Últimos 10 eventos
+        timestamp = event.get('timestamp', 'N/A')
+        event_type = event.get('type', 'UNKNOWN')
+        data = event.get('data', {})
+        
+        color = {
+            'COMPRAR': 'green',
+            'VENDER': 'red',
+            'AGUARDAR': 'orange'
+        }.get(event_type, '#666')
+        
+        html += f"<div style='border-left: 3px solid {color}; padding: 5px; margin: 5px 0; background: #f9f9f9;'>"
+        html += f"<strong>{timestamp}</strong> - {event_type}<br>"
+        if 'action' in data:
+            html += f"Ação: {data['action']}<br>"
+        if 'confidence' in data:
+            html += f"Confiança: {data['confidence']}%"
+        html += "</div>"
+    
+    html += "</div>"
+    return html
+
+def get_real_time_analysis_display():
+    """Obtém display da análise em tempo real."""
+    global real_time_integration, recent_events
+    
+    if not real_time_integration or not recent_events:
+        return "<div style='text-align: center; color: #666; padding: 40px;'>Aguardando dados do bot...</div>"
+    
+    # Pegar o evento mais recente
+    latest_event = recent_events[-1] if recent_events else None
+    
+    if not latest_event:
+        return "<div style='text-align: center; color: #666; padding: 40px;'>Nenhum evento disponível</div>"
+    
+    # Processar o evento mais recente
+    try:
+        event_data = latest_event.get('data', {})
+        if 'raw_text' in event_data:
+            analysis_result = main_analysis_function(event_data['raw_text'])
+            return f"<div style='border: 2px solid #4CAF50; padding: 15px; border-radius: 10px;'>{analysis_result}</div>"
+        else:
+            return "<div style='color: #666;'>Dados insuficientes para análise</div>"
+    except Exception as e:
+        return f"<div style='color: red;'>Erro na análise: {str(e)}</div>"
+
+def get_system_stats():
+    """Obtém estatísticas do sistema."""
+    global recent_events, real_time_integration
+    
+    total_events = len(recent_events)
+    monitor_status = "Ativo" if real_time_integration else "Inativo"
+    
+    # Contar tipos de eventos
+    event_counts = {}
+    for event in recent_events:
+        event_type = event.get('type', 'UNKNOWN')
+        event_counts[event_type] = event_counts.get(event_type, 0) + 1
+    
+    html = f"""
+    <div style='padding: 20px;'>
+        <h3>📊 Estatísticas do Sistema</h3>
+        <p><strong>Status do Monitor:</strong> {monitor_status}</p>
+        <p><strong>Total de Eventos:</strong> {total_events}</p>
+        <p><strong>Modelo IA:</strong> {model_info.get('description', 'N/A')}</p>
+        
+        <h4>📈 Distribuição de Eventos:</h4>
+        <ul>
+    """
+    
+    for event_type, count in event_counts.items():
+        html += f"<li>{event_type}: {count}</li>"
+    
+    html += "</ul></div>"
+    return html
+
+# Funções de controle de performance
+def start_performance_monitoring():
+    """Inicia o monitoramento de performance."""
+    global performance_monitor
+    
+    if not performance_monitor:
+        return "<div style='color: red;'>❌ Monitor de performance não disponível no modo standalone</div>"
+    
+    try:
+        if not performance_monitor.monitoring:
+            performance_monitor.start_monitoring(interval=5.0)
+            return "<div style='color: green;'>✅ Monitoramento de performance iniciado</div>"
+        else:
+            return "<div style='color: orange;'>⚠️ Monitoramento já está ativo</div>"
+    except Exception as e:
+        return f"<div style='color: red;'>❌ Erro ao iniciar monitoramento: {str(e)}</div>"
+
+def stop_performance_monitoring():
+    """Para o monitoramento de performance."""
+    global performance_monitor
+    
+    if not performance_monitor:
+        return "<div style='color: red;'>❌ Monitor de performance não disponível no modo standalone</div>"
+    
+    try:
+        if performance_monitor.monitoring:
+            performance_monitor.stop_monitoring()
+            return "<div style='color: orange;'>⏹️ Monitoramento de performance parado</div>"
+        else:
+            return "<div style='color: #666;'>Monitoramento já estava parado</div>"
+    except Exception as e:
+        return f"<div style='color: red;'>❌ Erro ao parar monitoramento: {str(e)}</div>"
+
+def reset_performance_stats():
+    """Reseta as estatísticas de performance."""
+    global performance_monitor
+    
+    if not performance_monitor:
+        return "<div style='color: red;'>❌ Monitor de performance não disponível no modo standalone</div>"
+    
+    try:
+        performance_monitor.reset_stats()
+        return "<div style='color: green;'>✅ Estatísticas resetadas com sucesso</div>"
+    except Exception as e:
+        return f"<div style='color: red;'>❌ Erro ao resetar estatísticas: {str(e)}</div>"
+
+def export_performance_metrics():
+    """Exporta métricas de performance."""
+    global performance_monitor
+    
+    if not performance_monitor:
+        return "<div style='color: red;'>❌ Monitor de performance não disponível no modo standalone</div>"
+    
+    try:
+        from datetime import datetime
+        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+        filepath = f"d:/hugging_face_spaces/performance_metrics_{timestamp}.json"
+        
+        performance_monitor.export_metrics(filepath, hours=24)
+        return f"<div style='color: green;'>✅ Métricas exportadas para: {filepath}</div>"
+    except Exception as e:
+        return f"<div style='color: red;'>❌ Erro ao exportar métricas: {str(e)}</div>"
+
+def get_system_metrics_display():
+    """Obtém display das métricas do sistema."""
+    global performance_monitor
+    
+    if not performance_monitor:
+        return "<div style='color: #666;'>Monitor de performance não disponível no modo standalone</div>"
+    
+    try:
+        current_metrics = performance_monitor.get_current_metrics()
+        
+        if not current_metrics:
+            return "<div style='color: #666;'>Nenhuma métrica disponível</div>"
+        
+        html = f"""
+        <div style='padding: 15px; border: 1px solid #ddd; border-radius: 8px;'>
+            <h4>🖥️ Métricas Atuais</h4>
+            <div style='display: grid; grid-template-columns: 1fr 1fr; gap: 10px;'>
+                <div>
+                    <strong>CPU:</strong> {current_metrics.cpu_usage:.1f}%<br>
+                    <div style='background: #f0f0f0; height: 10px; border-radius: 5px; margin: 5px 0;'>
+                        <div style='background: {'red' if current_metrics.cpu_usage > 80 else 'orange' if current_metrics.cpu_usage > 60 else 'green'}; 
+                                    height: 100%; width: {current_metrics.cpu_usage}%; border-radius: 5px;'></div>
+                    </div>
+                </div>
+                <div>
+                    <strong>Memória:</strong> {current_metrics.memory_usage:.1f}%<br>
+                    <div style='background: #f0f0f0; height: 10px; border-radius: 5px; margin: 5px 0;'>
+                        <div style='background: {'red' if current_metrics.memory_usage > 85 else 'orange' if current_metrics.memory_usage > 70 else 'green'}; 
+                                    height: 100%; width: {current_metrics.memory_usage}%; border-radius: 5px;'></div>
+                    </div>
+                </div>
+            </div>
+            <p><strong>Memória Disponível:</strong> {current_metrics.memory_available:.2f} GB</p>
+            <p><strong>Uso do Disco:</strong> {current_metrics.disk_usage:.1f}%</p>
+            <p><small>Última atualização: {current_metrics.timestamp.strftime('%H:%M:%S')}</small></p>
+        </div>
+        """
+        
+        return html
+        
+    except Exception as e:
+        return f"<div style='color: red;'>Erro ao obter métricas: {str(e)}</div>"
+
+def get_bot_statistics_display():
+    """Obtém display das estatísticas do bot."""
+    global performance_monitor
+    
+    if not performance_monitor:
+        return "<div style='color: #666;'>Monitor de performance não disponível no modo standalone</div>"
+    
+    try:
+        bot_stats = performance_monitor.get_bot_stats()
+        
+        success_rate = 0
+        if bot_stats.total_analyses > 0:
+            success_rate = (bot_stats.successful_analyses / bot_stats.total_analyses) * 100
+        
+        html = f"""
+        <div style='padding: 15px; border: 1px solid #ddd; border-radius: 8px;'>
+            <h4>🤖 Estatísticas do Bot</h4>
+            <div style='display: grid; grid-template-columns: 1fr 1fr; gap: 15px;'>
+                <div>
+                    <p><strong>Total de Análises:</strong> {bot_stats.total_analyses}</p>
+                    <p><strong>Sucessos:</strong> {bot_stats.successful_analyses}</p>
+                    <p><strong>Falhas:</strong> {bot_stats.failed_analyses}</p>
+                    <p><strong>Taxa de Sucesso:</strong> {success_rate:.1f}%</p>
+                </div>
+                <div>
+                    <p><strong>Tempo Médio:</strong> {bot_stats.average_analysis_time:.2f}s</p>
+                    <p><strong>Alertas Fibonacci:</strong> {bot_stats.fibonacci_alerts_count}</p>
+                    <p><strong>Última Atualização:</strong><br>
+                       <small>{bot_stats.last_update.strftime('%H:%M:%S') if bot_stats.last_update else 'N/A'}</small></p>
+                </div>
+            </div>
+            
+            <h5>📊 Sinais Gerados:</h5>
+            <div style='display: flex; gap: 10px;'>
+        """
+        
+        for signal, count in bot_stats.signals_generated.items():
+            color = {'COMPRAR': 'green', 'VENDER': 'red', 'AGUARDAR': 'orange'}.get(signal, '#666')
+            html += f"<span style='background: {color}; color: white; padding: 5px 10px; border-radius: 15px; font-size: 12px;'>{signal}: {count}</span>"
+        
+        html += "</div></div>"
+        
+        return html
+        
+    except Exception as e:
+        return f"<div style='color: red;'>Erro ao obter estatísticas: {str(e)}</div>"
+
+def get_performance_alerts_display():
+    """Obtém display dos alertas de performance."""
+    global performance_monitor
+    
+    if not performance_monitor:
+        return "<div style='color: #666;'>Monitor de performance não disponível no modo standalone</div>"
+    
+    try:
+        summary = performance_monitor.get_performance_summary()
+        active_alerts = summary.get('active_alerts', [])
+        
+        if not active_alerts:
+            return "<div style='color: green;'>✅ Nenhum alerta ativo - Sistema operando normalmente</div>"
+        
+        html = "<div style='padding: 10px;'>"
+        for alert in active_alerts:
+            alert_text = {
+                'high_cpu': '🔥 CPU Alto',
+                'high_memory': '💾 Memória Alta',
+                'slow_analysis': '🐌 Análise Lenta',
+                'high_error_rate': '❌ Taxa de Erro Alta'
+            }.get(alert, alert)
+            
+            html += f"<div style='background: #ffebee; border-left: 4px solid #f44336; padding: 10px; margin: 5px 0;'>⚠️ {alert_text}</div>"
+        
+        html += "</div>"
+        return html
+        
+    except Exception as e:
+        return f"<div style='color: red;'>Erro ao obter alertas: {str(e)}</div>"
+
+def get_optimization_suggestions_display():
+    """Obtém display das sugestões de otimização."""
+    global performance_monitor
+    
+    if not performance_monitor:
+        return "<div style='color: #666;'>Monitor de performance não disponível no modo standalone</div>"
+    
+    try:
+        suggestions = performance_monitor.optimize_performance()
+        
+        html = "<div style='padding: 10px;'>"
+        for i, suggestion in enumerate(suggestions, 1):
+            icon = "💡" if "normal" in suggestion.lower() else "⚠️"
+            color = "#e8f5e8" if "normal" in suggestion.lower() else "#fff3cd"
+            
+            html += f"<div style='background: {color}; padding: 10px; margin: 5px 0; border-radius: 5px;'>{icon} {suggestion}</div>"
+        
+        html += "</div>"
+        return html
+        
+    except Exception as e:
+        return f"<div style='color: red;'>Erro ao obter sugestões: {str(e)}</div>"
+
 # Inicializar engines e criar interface
 initialize_engines()
 demo = create_interface()

config/__init__.py

@@ -0,0 +1,25 @@
+"""Pacote de configurações do Vampire Trading Bot."""
+
+from .config import (
+    AppConfig,
+    TechnicalAnalysisConfig,
+    ScoringConfig,
+    TradingConfig,
+    UIConfig,
+    RegexPatterns,
+    AIConfig,
+    ExampleData,
+    FINANCIAL_MODELS
+)
+
+__all__ = [
+    'AppConfig',
+    'TechnicalAnalysisConfig', 
+    'ScoringConfig',
+    'TradingConfig',
+    'UIConfig',
+    'RegexPatterns',
+    'AIConfig',
+    'ExampleData',
+    'FINANCIAL_MODELS'
+]

config/config.py

@@ -0,0 +1,209 @@
+"""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/README.md

@@ -0,0 +1,86 @@
+# 📈 Vampire Trading Bot - Documentação
+
+## Visão Geral
+
+O Vampire Trading Bot é um sistema avançado de análise de mercado financeiro que combina análise técnica tradicional com inteligência artificial para fornecer sinais de trading precisos e análises de Fibonacci sofisticadas.
+
+## 🏗️ Arquitetura do Sistema
+
+O sistema é construído com uma arquitetura modular que permite flexibilidade e escalabilidade:
+
+### Componentes Principais
+
+- **Core Engine**: Motor principal de análise técnica e de sentimento
+- **Fibonacci Engine**: Sistema avançado de análise de Fibonacci com padrões harmônicos
+- **Real-time Integration**: Integração em tempo real com logs de trading
+- **Performance Monitor**: Monitoramento de performance e métricas do sistema
+- **UI Interface**: Interface web moderna construída com Gradio
+
+### Fluxo de Dados
+
+```
+Dados de Mercado → Análise Técnica → Análise de Sentimento → Fibonacci → Interface
+                                                                    ↓
+                    Performance Monitor ← Real-time Integration ←────┘
+```
+
+## 📚 Documentação
+
+- [Guia de Instalação](installation.md)
+- [Arquitetura do Sistema](architecture.md)
+- [APIs e Interfaces](api-reference.md)
+- [Guia do Desenvolvedor](developer-guide.md)
+- [Configuração](configuration.md)
+- [Troubleshooting](troubleshooting.md)
+
+## 🚀 Início Rápido
+
+1. Clone o repositório
+2. Instale as dependências: `pip install -r requirements.txt`
+3. Execute o aplicativo: `python app.py`
+4. Acesse a interface em `http://localhost:7860`
+
+## 🔧 Tecnologias Utilizadas
+
+- **Python 3.13+**
+- **Gradio**: Interface web interativa
+- **Transformers**: Modelos de IA para análise de sentimento
+- **PyTorch**: Framework de deep learning
+- **NumPy/Pandas**: Processamento de dados
+- **Psutil**: Monitoramento de sistema
+
+## 📊 Funcionalidades
+
+### Análise Técnica
+- RSI (Relative Strength Index)
+- Médias Móveis Exponenciais (EMA)
+- Bandas de Bollinger
+- Análise de Volume e Momentum
+- Detecção de Setups de Scalping
+
+### Análise de Fibonacci
+- Níveis de Retração
+- Níveis de Extensão
+- Projeções Temporais
+- Zonas de Confluência
+- Padrões Harmônicos
+
+### Análise de Sentimento
+- Processamento de texto com IA
+- Modelos financeiros especializados
+- Análise de palavras-chave
+- Pontuação de sentimento
+
+### Monitoramento
+- Métricas de performance em tempo real
+- Histórico de análises
+- Alertas de sistema
+- Estatísticas de precisão
+
+## 📝 Licença
+
+Este projeto é proprietário e confidencial.
+
+## 🤝 Contribuição
+
+Veja o [Guia do Desenvolvedor](developer-guide.md) para informações sobre como contribuir.

docs/api-reference.md

@@ -0,0 +1,569 @@
+# 📚 Referência de APIs e Interfaces
+
+## Visão Geral
+
+Este documento descreve todas as APIs, interfaces e contratos entre os módulos do Vampire Trading Bot. Cada seção inclui exemplos de uso, parâmetros esperados e formatos de resposta.
+
+## 🔧 Core Engines
+
+### TechnicalAnalysisEngine
+
+#### Classe Principal
+```python
+class TechnicalAnalysisEngine:
+    def __init__(self):
+        """Inicializa o engine de análise técnica."""
+    
+    def analyze_market_data(self, market_text: str) -> Dict[str, Any]:
+        """Analisa dados de mercado a partir de texto.
+        
+        Args:
+            market_text (str): Texto contendo dados de mercado
+            
+        Returns:
+            Dict[str, Any]: Resultado da análise técnica
+            {
+                'market_data': MarketData,
+                'technical_signals': List[TechnicalSignal],
+                'scalping_setups': List[ScalpingSetup],
+                'risk_analysis': RiskAnalysis,
+                'overall_signal': str,
+                'confidence': float
+            }
+        """
+```
+
+#### Estruturas de Dados
+
+```python
+@dataclass
+class MarketData:
+    """Dados básicos de mercado."""
+    symbol: str              # Símbolo do ativo
+    current_price: float     # Preço atual
+    variation: float         # Variação absoluta
+    variation_percent: float # Variação percentual
+    high: float             # Máxima do período
+    low: float              # Mínima do período
+    volume: float           # Volume negociado
+    timestamp: str          # Timestamp da cotação
+
+@dataclass
+class TechnicalSignal:
+    """Sinal de indicador técnico."""
+    indicator: str          # Nome do indicador (RSI, EMA, etc.)
+    value: float           # Valor atual do indicador
+    signal: str            # Sinal gerado (COMPRAR, VENDER, NEUTRO)
+    confidence: float      # Confiança do sinal (0-100)
+    description: str       # Descrição detalhada
+    timestamp: str         # Timestamp do cálculo
+
+@dataclass
+class ScalpingSetup:
+    """Setup de scalping detectado."""
+    name: str              # Nome do setup
+    entry_price: float     # Preço de entrada
+    stop_loss: float       # Stop loss
+    take_profit: float     # Take profit
+    risk_reward: float     # Relação risco/recompensa
+    confidence: float      # Confiança do setup
+    timeframe: str         # Timeframe recomendado
+```
+
+#### Exemplo de Uso
+
+```python
+engine = TechnicalAnalysisEngine()
+
+market_text = """
+📊 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
+"""
+
+result = engine.analyze_market_data(market_text)
+print(f"Sinal geral: {result['overall_signal']}")
+print(f"Confiança: {result['confidence']}%")
+```
+
+### SentimentAnalysisEngine
+
+#### Classe Principal
+```python
+class SentimentAnalysisEngine:
+    def __init__(self, model_name: str = None):
+        """Inicializa o engine de análise de sentimento.
+        
+        Args:
+            model_name (str, optional): Nome do modelo a usar
+        """
+    
+    def analyze_sentiment(self, text: str) -> SentimentResult:
+        """Analisa sentimento de um texto.
+        
+        Args:
+            text (str): Texto para análise (max 512 tokens)
+            
+        Returns:
+            SentimentResult: Resultado da análise
+        """
+    
+    def batch_analyze(self, texts: List[str]) -> List[SentimentResult]:
+        """Analisa múltiplos textos em lote.
+        
+        Args:
+            texts (List[str]): Lista de textos
+            
+        Returns:
+            List[SentimentResult]: Lista de resultados
+        """
+```
+
+#### Estruturas de Dados
+
+```python
+@dataclass
+class SentimentResult:
+    """Resultado de análise de sentimento."""
+    text: str                    # Texto original
+    sentiment: str               # POSITIVO, NEGATIVO, NEUTRO
+    confidence: float            # Confiança (0-100)
+    scores: Dict[str, float]     # Scores detalhados por classe
+    keywords: List[str]          # Palavras-chave extraídas
+    financial_indicators: List[str] # Indicadores financeiros detectados
+    timestamp: str               # Timestamp da análise
+    model_used: str             # Modelo utilizado
+```
+
+#### Exemplo de Uso
+
+```python
+engine = SentimentAnalysisEngine()
+
+text = "O mercado está muito otimista hoje, com forte alta nos índices."
+result = engine.analyze_sentiment(text)
+
+print(f"Sentimento: {result.sentiment}")
+print(f"Confiança: {result.confidence}%")
+print(f"Palavras-chave: {result.keywords}")
+```
+
+### AdvancedFibonacciEngine
+
+#### Classe Principal
+```python
+class AdvancedFibonacciEngine:
+    def __init__(self):
+        """Inicializa o engine de análise de Fibonacci."""
+    
+    def perform_advanced_analysis(
+        self,
+        swing_high: float,
+        swing_low: float,
+        current_price: float,
+        historical_data: Optional[pd.DataFrame] = None
+    ) -> AdvancedFibonacciAnalysis:
+        """Realiza análise avançada de Fibonacci.
+        
+        Args:
+            swing_high (float): Preço do swing high
+            swing_low (float): Preço do swing low
+            current_price (float): Preço atual
+            historical_data (pd.DataFrame, optional): Dados históricos
+            
+        Returns:
+            AdvancedFibonacciAnalysis: Análise completa
+        """
+```
+
+#### Estruturas de Dados
+
+```python
+@dataclass
+class FibonacciLevel:
+    """Nível de Fibonacci."""
+    level: float                 # Nível (0.236, 0.382, etc.)
+    price: float                # Preço do nível
+    type: str                   # 'retracement', 'extension', 'projection'
+    ratio: float                # Ratio de Fibonacci
+    distance_from_current: float # Distância do preço atual
+    strength: float             # Força do nível (0-100)
+
+@dataclass
+class ConfluenceZone:
+    """Zona de confluência."""
+    price_range: Tuple[float, float] # Faixa de preços
+    levels_count: int               # Número de níveis na zona
+    strength: float                 # Força da zona
+    types: List[str]               # Tipos de níveis presentes
+
+@dataclass
+class AdvancedFibonacciAnalysis:
+    """Análise completa de Fibonacci."""
+    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
+```
+
+## 🔄 Real-time Integration
+
+### RealTimeIntegration
+
+#### Classe Principal
+```python
+class RealTimeIntegration:
+    def __init__(self, log_file_path: str):
+        """Inicializa integração em tempo real.
+        
+        Args:
+            log_file_path (str): Caminho para arquivo de log
+        """
+    
+    def start(self):
+        """Inicia monitoramento em tempo real."""
+    
+    def stop(self):
+        """Para monitoramento."""
+    
+    def subscribe(self, callback: Callable[[BotEvent], None]):
+        """Inscreve callback para eventos.
+        
+        Args:
+            callback: Função a ser chamada para cada evento
+        """
+```
+
+#### Estruturas de Dados
+
+```python
+@dataclass
+class BotEvent:
+    """Evento do bot em tempo real."""
+    timestamp: datetime
+    event_type: str              # 'new_analysis', 'fibonacci_alert', etc.
+    data: Dict[str, Any]        # Dados do evento
+    priority: str               # 'low', 'normal', 'high', 'critical'
+
+@dataclass
+class RealTimeConfig:
+    """Configuração de tempo real."""
+    log_file_path: str
+    check_interval: float        # Intervalo de verificação (segundos)
+    max_queue_size: int         # Tamanho máximo da fila
+    enable_notifications: bool   # Habilitar notificações
+    auto_analysis: bool         # Análise automática
+    backup_logs: bool           # Backup de logs
+```
+
+## 📊 Performance Monitor
+
+### PerformanceMonitor
+
+#### Classe Principal
+```python
+class PerformanceMonitor:
+    def __init__(self, max_metrics_history: int = 1000):
+        """Inicializa monitor de performance."""
+    
+    def start_monitoring(self, interval: float = 5.0):
+        """Inicia monitoramento.
+        
+        Args:
+            interval (float): Intervalo entre coletas (segundos)
+        """
+    
+    def record_analysis_time(self, analysis_time: float):
+        """Registra tempo de análise.
+        
+        Args:
+            analysis_time (float): Tempo em segundos
+        """
+    
+    def get_performance_summary(self) -> Dict[str, Any]:
+        """Retorna resumo de performance.
+        
+        Returns:
+            Dict com métricas de performance
+        """
+```
+
+#### Estruturas de Dados
+
+```python
+@dataclass
+class PerformanceMetrics:
+    """Métricas de performance."""
+    timestamp: datetime
+    cpu_usage: float            # Uso de CPU (%)
+    memory_usage: float         # Uso de memória (%)
+    memory_available: float     # Memória disponível (MB)
+    disk_usage: float          # Uso de disco (%)
+    analysis_time: float       # Tempo de análise (s)
+    events_processed: int      # Eventos processados
+    errors_count: int          # Contagem de erros
+    bot_signals_count: int     # Sinais do bot
+    fibonacci_alerts_count: int # Alertas de Fibonacci
+```
+
+## 🔍 Log Parser
+
+### VampireBotLogParser
+
+#### Classe Principal
+```python
+class VampireBotLogParser:
+    def __init__(self):
+        """Inicializa parser de logs."""
+    
+    def parse_log_content(self, log_content: str) -> Optional[BotAnalysis]:
+        """Faz parse de conteúdo de log.
+        
+        Args:
+            log_content (str): Conteúdo do log
+            
+        Returns:
+            BotAnalysis ou None se parsing falhar
+        """
+    
+    def parse_log_file(self, file_path: str) -> Optional[BotAnalysis]:
+        """Faz parse de arquivo de log.
+        
+        Args:
+            file_path (str): Caminho do arquivo
+            
+        Returns:
+            BotAnalysis ou None se parsing falhar
+        """
+```
+
+#### Estruturas de Dados
+
+```python
+@dataclass
+class BotAnalysis:
+    """Análise completa do bot."""
+    analysis_number: int
+    timestamp: str
+    market_data: MarketData
+    technical_indicators: TechnicalIndicators
+    fibonacci_analysis: FibonacciAnalysis
+    performance_time: Optional[float] = None
+
+@dataclass
+class TechnicalIndicators:
+    """Indicadores técnicos do log."""
+    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
+```
+
+## 🎨 UI Interface
+
+### GradioInterface
+
+#### Classe Principal
+```python
+class GradioInterface:
+    def __init__(self):
+        """Inicializa interface Gradio."""
+    
+    def create_interface(self) -> gr.Blocks:
+        """Cria interface completa.
+        
+        Returns:
+            gr.Blocks: Interface Gradio configurada
+        """
+    
+    def launch(self, **kwargs):
+        """Lança a interface.
+        
+        Args:
+            **kwargs: Argumentos para gr.launch()
+        """
+```
+
+#### Componentes da Interface
+
+```python
+class UIComponents:
+    """Componentes reutilizáveis da UI."""
+    
+    @staticmethod
+    def create_market_input() -> gr.Textbox:
+        """Cria campo de entrada de dados de mercado."""
+    
+    @staticmethod
+    def create_sentiment_input() -> gr.Textbox:
+        """Cria campo de entrada para análise de sentimento."""
+    
+    @staticmethod
+    def create_fibonacci_inputs() -> Tuple[gr.Number, gr.Number, gr.Number]:
+        """Cria campos para análise de Fibonacci."""
+```
+
+## 🛠️ Utilities
+
+### Utilitários de Validação
+
+```python
+class ValidationUtils:
+    @staticmethod
+    def validate_market_data(data: Dict[str, Any]) -> bool:
+        """Valida dados de mercado.
+        
+        Args:
+            data: Dicionário com dados de mercado
+            
+        Returns:
+            bool: True se válido
+        """
+    
+    @staticmethod
+    def validate_text_input(text: str) -> bool:
+        """Valida entrada de texto.
+        
+        Args:
+            text: Texto a validar
+            
+        Returns:
+            bool: True se válido
+        """
+```
+
+### Utilitários de Formatação
+
+```python
+class FormatUtils:
+    @staticmethod
+    def format_price(price: float) -> str:
+        """Formata preço com separadores."""
+    
+    @staticmethod
+    def format_percentage(value: float) -> str:
+        """Formata porcentagem com sinal."""
+    
+    @staticmethod
+    def format_analysis_result(result: Dict[str, Any]) -> str:
+        """Formata resultado de análise para exibição."""
+```
+
+## 📋 Códigos de Erro
+
+### Códigos de Sistema
+- `SYS_001`: Erro de inicialização
+- `SYS_002`: Erro de configuração
+- `SYS_003`: Erro de memória insuficiente
+
+### Códigos de Análise
+- `ANA_001`: Dados de mercado inválidos
+- `ANA_002`: Erro no modelo de IA
+- `ANA_003`: Timeout de análise
+- `ANA_004`: Erro de parsing de texto
+
+### Códigos de Interface
+- `UI_001`: Erro de renderização
+- `UI_002`: Entrada inválida
+- `UI_003`: Erro de comunicação
+
+## 🔧 Configuração de APIs
+
+### Variáveis de Ambiente
+
+```bash
+# Configurações de modelo
+FINBERT_MODEL_PATH=/path/to/model
+MAX_TEXT_LENGTH=512
+
+# Configurações de performance
+MAX_WORKERS=4
+CACHE_SIZE=1000
+
+# Configurações de logging
+LOG_LEVEL=INFO
+LOG_FILE_PATH=/path/to/logs
+```
+
+### Configuração via Arquivo
+
+```python
+# config.py
+class APIConfig:
+    MAX_TEXT_LENGTH = 512
+    TIMEOUT_SECONDS = 30
+    RETRY_ATTEMPTS = 3
+    CACHE_TTL = 3600
+```
+
+## 📝 Exemplos de Integração
+
+### Exemplo Completo
+
+```python
+from market_analysis import TechnicalAnalysisEngine
+from sentiment_analysis import SentimentAnalysisEngine
+from fibonacci_analysis import AdvancedFibonacciEngine
+
+# Inicializar engines
+tech_engine = TechnicalAnalysisEngine()
+sentiment_engine = SentimentAnalysisEngine()
+fib_engine = AdvancedFibonacciEngine()
+
+# Dados de entrada
+market_text = "Preço: 140135, Variação: +5"
+sentiment_text = "Mercado muito otimista hoje"
+
+# Análises
+tech_result = tech_engine.analyze_market_data(market_text)
+sentiment_result = sentiment_engine.analyze_sentiment(sentiment_text)
+fib_result = fib_engine.perform_advanced_analysis(140570, 139540, 140135)
+
+# Consolidar resultados
+final_result = {
+    'technical': tech_result,
+    'sentiment': sentiment_result,
+    'fibonacci': fib_result,
+    'timestamp': datetime.now().isoformat()
+}
+
+print(json.dumps(final_result, indent=2, default=str))
+```
+
+## 🚀 Próximas Versões da API
+
+### v2.0 (Planejado)
+- REST API completa
+- WebSocket para tempo real
+- Autenticação e autorização
+- Rate limiting
+- Documentação OpenAPI/Swagger
+
+### v3.0 (Futuro)
+- GraphQL API
+- Microserviços
+- API Gateway
+- Métricas avançadas
+- Multi-tenancy

docs/architecture.md

@@ -0,0 +1,350 @@
+# 🏗️ Arquitetura do Sistema
+
+## 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.
+
+## Diagrama de Arquitetura
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                        VAMPIRE TRADING BOT                      │
+├─────────────────────────────────────────────────────────────────┤
+│                     📱 PRESENTATION LAYER                       │
+│  ┌─────────────────┐  ┌─────────────────┐  ┌─────────────────┐ │
+│  │   Gradio UI     │  │   REST API      │  │   WebSocket     │ │
+│  │   (ui.py)       │  │   (future)      │  │   (future)      │ │
+│  └─────────────────┘  └─────────────────┘  └─────────────────┘ │
+├─────────────────────────────────────────────────────────────────┤
+│                      🧠 BUSINESS LOGIC LAYER                    │
+│  ┌─────────────────┐  ┌─────────────────┐  ┌─────────────────┐ │
+│  │ Technical       │  │ Sentiment       │  │ Fibonacci       │ │
+│  │ Analysis Engine │  │ Analysis Engine │  │ Analysis Engine │ │
+│  │ (market_*.py)   │  │ (sentiment_*.py)│  │ (fibonacci_*.py)│ │
+│  └─────────────────┘  └─────────────────┘  └─────────────────┘ │
+│  ┌─────────────────┐  ┌─────────────────┐  ┌─────────────────┐ │
+│  │ Real-time       │  │ Performance     │  │ Log Parser      │ │
+│  │ Integration      │  │ Monitor         │  │ (log_parser.py) │ │
+│  │ (real_time_*.py)│  │ (performance_*) │  │                 │ │
+│  └─────────────────┘  └─────────────────┘  └─────────────────┘ │
+├─────────────────────────────────────────────────────────────────┤
+│                       🔧 INFRASTRUCTURE LAYER                   │
+│  ┌─────────────────┐  ┌─────────────────┐  ┌─────────────────┐ │
+│  │ Configuration   │  │ Utilities       │  │ Logging         │ │
+│  │ (config.py)     │  │ (utils.py)      │  │ (built-in)      │ │
+│  └─────────────────┘  └─────────────────┘  └─────────────────┘ │
+│  ┌─────────────────┐  ┌─────────────────┐  ┌─────────────────┐ │
+│  │ AI Models       │  │ File System     │  │ Threading       │ │
+│  │ (transformers)  │  │ (pathlib)       │  │ (asyncio)       │ │
+│  └─────────────────┘  └─────────────────┘  └─────────────────┘ │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+## Componentes Principais
+
+### 1. 📱 Camada de Apresentação
+
+#### Gradio Interface (`ui.py`)
+- **Responsabilidade**: Interface web interativa
+- **Tecnologia**: Gradio 4.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
+```
+
+### 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()
+        # ...
+```
+
+#### 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
+
+```python
+class SentimentAnalysisEngine:
+    def __init__(self):
+        self.model_manager = ModelManager()
+        self.preprocessor = TextPreprocessor()
+        self.analyzer = SentimentAnalyzer()
+```
+
+#### Advanced Fibonacci Engine (`fibonacci_analysis.py`)
+- **Responsabilidade**: Análise avançada de Fibonacci
+- **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
+
+```python
+class AdvancedFibonacciEngine:
+    def perform_advanced_analysis(
+        self, swing_high: float, swing_low: float, current_price: float
+    ) -> AdvancedFibonacciAnalysis:
+        # Análise completa de Fibonacci
+```
+
+#### 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
+- **Funcionalidades**:
+  - Extração de dados de mercado
+  - Parsing de indicadores técnicos
+  - Análise de Fibonacci dos logs
+
+### 3. 🔧 Camada de Infraestrutura
+
+#### 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
+
+## Fluxo de Dados
+
+### 1. Fluxo de Análise Principal
+
+```
+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
+```
+
+### 2. Fluxo de Monitoramento
+
+```
+Sistema → Performance Monitor → Métricas → Dashboard
+    ↓
+Logs → Log Parser → Eventos → Real-time Integration → UI
+```
+
+## Padrões de Design Utilizados
+
+### 1. **Strategy Pattern**
+- Diferentes analisadores técnicos
+- Múltiplos modelos de IA
+- Estratégias de formatação
+
+### 2. **Observer Pattern**
+- Sistema de eventos em tempo real
+- Notificações de performance
+- Atualizações de UI
+
+### 3. **Factory Pattern**
+- Criação de analisadores
+- Instanciação de modelos
+- Geração de interfaces
+
+### 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
+
+1. Criar classe herdando de `BaseAnalyzer`
+2. Implementar método `analyze()`
+3. Registrar no `TechnicalAnalysisEngine`
+
+### Adicionando Novos Modelos de IA
+
+1. Adicionar modelo em `config.py`
+2. Implementar carregamento no `ModelManager`
+3. Testar compatibilidade
+
+### Adicionando Novas Interfaces
+
+1. Implementar interface seguindo padrão
+2. Integrar com engines existentes
+3. Configurar roteamento
+
+## Performance e Otimização
+
+### Estratégias de Cache
+- Cache de modelos de IA
+- Cache de cálculos técnicos
+- Cache de resultados de análise
+
+### Processamento Assíncrono
+- Análises paralelas
+- Carregamento assíncrono de modelos
+- Processamento de eventos em background
+
+### Otimização de Memória
+- Lazy loading de modelos
+- Limpeza automática de cache
+- Monitoramento de uso de memória
+
+## Segurança
+
+### Validação de Entrada
+- Sanitização de texto
+- Validação de parâmetros
+- Limites de tamanho
+
+### Tratamento de Erros
+- Try-catch abrangente
+- Fallbacks para modo standalone
+- Logging detalhado de erros
+
+### Isolamento de Recursos
+- Ambientes virtuais
+- Limitação de recursos
+- Timeouts de operação
+
+## Monitoramento e Observabilidade
+
+### 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

docs/configuration.md

@@ -0,0 +1,606 @@
+# ⚙️ Guia de Configuração
+
+## Visão Geral
+
+Este documento descreve todas as opções de configuração disponíveis no Vampire Trading Bot, incluindo configurações de modelos de IA, análise técnica, interface do usuário e performance.
+
+## 📁 Arquivo Principal de Configuração
+
+Todas as configurações estão centralizadas no arquivo `config.py`. Este arquivo contém classes de configuração organizadas por funcionalidade.
+
+### Estrutura do Arquivo
+
+```python
+# config.py
+class FinancialModels:      # Modelos de IA
+class TechnicalAnalysis:    # Análise técnica
+class ScoringConfig:        # Pontuação e confiança
+class TradingConfig:        # Configurações de trading
+class UIConfig:             # Interface do usuário
+class RegexPatterns:        # Padrões de extração
+class AIConfig:             # Configurações de IA
+class AppConfig:            # Configurações gerais
+```
+
+## 🤖 Configuração de Modelos de IA
+
+### FinancialModels
+
+```python
+class FinancialModels:
+    """Modelos de IA para análise financeira."""
+    
+    # Lista de modelos disponíveis (ordenados por performance/tamanho)
+    FINANCIAL_MODELS = [
+        "nlptown/bert-base-multilingual-uncased-sentiment",  # Leve, multilíngue
+        "cardiffnlp/twitter-roberta-base-sentiment-latest",   # Médio, redes sociais
+        "ProsusAI/finbert",                                   # Pesado, financeiro
+        "mrm8488/distilroberta-finetuned-financial-news-sentiment-analysis"
+    ]
+    
+    # Modelo padrão (usado se não especificado)
+    DEFAULT_MODEL = FINANCIAL_MODELS[0]
+    
+    # Modelos alternativos para fallback
+    FALLBACK_MODELS = [
+        "cardiffnlp/twitter-roberta-base-sentiment-latest",
+        "nlptown/bert-base-multilingual-uncased-sentiment"
+    ]
+```
+
+#### Como Configurar
+
+1. **Escolher Modelo por Performance**:
+   ```python
+   # Para melhor performance (mais leve)
+   DEFAULT_MODEL = "nlptown/bert-base-multilingual-uncased-sentiment"
+   
+   # Para melhor precisão (mais pesado)
+   DEFAULT_MODEL = "ProsusAI/finbert"
+   ```
+
+2. **Adicionar Novos Modelos**:
+   ```python
+   FINANCIAL_MODELS.append("seu-modelo/nome-do-modelo")
+   ```
+
+### AIConfig
+
+```python
+class AIConfig:
+    """Configurações gerais de IA."""
+    
+    # Tamanho máximo de texto para análise
+    MAX_TEXT_LENGTH = 512
+    
+    # Pipeline de análise de sentimento
+    SENTIMENT_PIPELINE = "sentiment-analysis"
+    
+    # Configurações de cache
+    ENABLE_MODEL_CACHE = True
+    CACHE_SIZE = 100
+    
+    # Timeout para carregamento de modelos (segundos)
+    MODEL_LOAD_TIMEOUT = 60
+    
+    # Usar GPU se disponível
+    USE_GPU = True
+    
+    # Batch size para processamento
+    BATCH_SIZE = 8
+```
+
+#### Configurações Avançadas de IA
+
+```python
+# Configuração de memória
+AIConfig.MAX_TEXT_LENGTH = 256  # Reduzir para economizar memória
+AIConfig.BATCH_SIZE = 4         # Reduzir batch size
+
+# Configuração de performance
+AIConfig.USE_GPU = False        # Forçar uso de CPU
+AIConfig.ENABLE_MODEL_CACHE = False  # Desabilitar cache
+
+# Configuração de timeout
+AIConfig.MODEL_LOAD_TIMEOUT = 120  # Aumentar timeout
+```
+
+## 📊 Configuração de Análise Técnica
+
+### TechnicalAnalysis
+
+```python
+class TechnicalAnalysis:
+    """Configurações para análise técnica."""
+    
+    # Configurações do RSI
+    RSI_PERIOD = 14
+    RSI_OVERSOLD = 30
+    RSI_OVERBOUGHT = 70
+    
+    # Configurações das Bandas de Bollinger
+    BOLLINGER_PERIOD = 20
+    BOLLINGER_STD = 2
+    
+    # Configurações das EMAs
+    EMA_FAST_PERIOD = 9
+    EMA_SLOW_PERIOD = 21
+    
+    # Configurações de Volume
+    VOLUME_MA_PERIOD = 20
+    HIGH_VOLUME_MULTIPLIER = 1.5
+    
+    # Configurações de Momentum
+    MOMENTUM_PERIOD = 10
+    MOMENTUM_THRESHOLD = 0.02
+```
+
+#### Personalização de Indicadores
+
+```python
+# RSI mais sensível
+TechnicalAnalysis.RSI_PERIOD = 10
+TechnicalAnalysis.RSI_OVERSOLD = 25
+TechnicalAnalysis.RSI_OVERBOUGHT = 75
+
+# Bandas de Bollinger mais apertadas
+TechnicalAnalysis.BOLLINGER_STD = 1.5
+
+# EMAs mais rápidas
+TechnicalAnalysis.EMA_FAST_PERIOD = 5
+TechnicalAnalysis.EMA_SLOW_PERIOD = 13
+```
+
+## 🎯 Configuração de Trading
+
+### TradingConfig
+
+```python
+class TradingConfig:
+    """Configurações de trading e gestão de risco."""
+    
+    # Stop Loss padrão (percentual)
+    DEFAULT_STOP_LOSS = 0.5  # 0.5%
+    
+    # Take Profit padrão (percentual)
+    DEFAULT_TAKE_PROFIT = 1.0  # 1.0%
+    
+    # Relação risco/recompensa mínima
+    MIN_RISK_REWARD = 1.5
+    
+    # Tamanho de posição padrão
+    DEFAULT_POSITION_SIZE = 1.0
+    
+    # Configurações de scalping
+    SCALPING_TIMEFRAMES = ["1m", "5m", "15m"]
+    SCALPING_MIN_VOLUME = 1000
+    
+    # Configurações de volatilidade
+    LOW_VOLATILITY_THRESHOLD = 0.5
+    HIGH_VOLATILITY_THRESHOLD = 2.0
+```
+
+#### Estratégias de Risco
+
+```python
+# Estratégia conservadora
+TradingConfig.DEFAULT_STOP_LOSS = 0.3
+TradingConfig.DEFAULT_TAKE_PROFIT = 0.6
+TradingConfig.MIN_RISK_REWARD = 2.0
+
+# Estratégia agressiva
+TradingConfig.DEFAULT_STOP_LOSS = 0.8
+TradingConfig.DEFAULT_TAKE_PROFIT = 1.5
+TradingConfig.MIN_RISK_REWARD = 1.2
+```
+
+## 🎨 Configuração da Interface
+
+### UIConfig
+
+```python
+class UIConfig:
+    """Configurações da interface do usuário."""
+    
+    # Informações do aplicativo
+    TITLE = "📈 Vampire Trading Bot"
+    SUBTITLE = "Análise Avançada de Mercado com IA"
+    DESCRIPTION = "Sistema completo de análise técnica e sentimento"
+    
+    # Emojis para diferentes ações
+    ACTION_EMOJIS = {
+        "COMPRAR": "🟢",
+        "VENDER": "🔴",
+        "AGUARDAR": "🟡",
+        "NEUTRO": "⚪"
+    }
+    
+    # Cores para diferentes elementos
+    COLORS = {
+        "success": "#28a745",
+        "danger": "#dc3545",
+        "warning": "#ffc107",
+        "info": "#17a2b8",
+        "primary": "#007bff"
+    }
+    
+    # Mensagens de status
+    STATUS_MESSAGES = {
+        "loading": "🔄 Processando análise...",
+        "success": "✅ Análise concluída com sucesso!",
+        "error": "❌ Erro durante a análise",
+        "no_data": "⚠️ Nenhum dado fornecido"
+    }
+```
+
+#### Personalização da Interface
+
+```python
+# Tema escuro
+UIConfig.COLORS = {
+    "success": "#00ff88",
+    "danger": "#ff4444",
+    "warning": "#ffaa00",
+    "info": "#00aaff",
+    "primary": "#8800ff"
+}
+
+# Personalizar título
+UIConfig.TITLE = "🧛 Meu Bot de Trading"
+UIConfig.SUBTITLE = "Análise Personalizada"
+```
+
+## 🔍 Configuração de Padrões Regex
+
+### RegexPatterns
+
+```python
+class RegexPatterns:
+    """Padrões regex para extração de dados."""
+    
+    # Extração de preços
+    PRICE_PATTERN = r"Preço.*?([\d,]+\.\d+)"
+    
+    # Extração de variação
+    VARIATION_PATTERN = r"Variação.*?([+-]?[\d,]+\.\d+)"
+    
+    # Extração de porcentagem
+    PERCENTAGE_PATTERN = r"\(([+-]?\d+\.\d+)%\)"
+    
+    # Extração de volume
+    VOLUME_PATTERN = r"Volume.*?(\d+)"
+    
+    # Extração de RSI
+    RSI_PATTERN = r"RSI.*?(\d+\.\d+)"
+    
+    # Extração de EMAs
+    EMA_PATTERN = r"EMA.*?(\d+\.\d+)"
+```
+
+#### Personalização de Padrões
+
+```python
+# Padrões para formato brasileiro
+RegexPatterns.PRICE_PATTERN = r"R\$\s*([\d.]+,\d+)"
+RegexPatterns.PERCENTAGE_PATTERN = r"\(([+-]?\d+,\d+)%\)"
+
+# Padrões para outros idiomas
+RegexPatterns.PRICE_PATTERN = r"Price.*?([\d,]+\.\d+)"
+```
+
+## 📈 Configuração de Pontuação
+
+### ScoringConfig
+
+```python
+class ScoringConfig:
+    """Configurações de pontuação e confiança."""
+    
+    # Pesos para diferentes análises
+    TECHNICAL_WEIGHT = 0.4
+    SENTIMENT_WEIGHT = 0.3
+    FIBONACCI_WEIGHT = 0.3
+    
+    # Thresholds de confiança
+    HIGH_CONFIDENCE_THRESHOLD = 80
+    MEDIUM_CONFIDENCE_THRESHOLD = 60
+    LOW_CONFIDENCE_THRESHOLD = 40
+    
+    # Multiplicadores de pontuação
+    STRONG_SIGNAL_MULTIPLIER = 1.5
+    WEAK_SIGNAL_MULTIPLIER = 0.7
+    
+    # Penalizações
+    CONFLICTING_SIGNALS_PENALTY = 0.2
+    LOW_VOLUME_PENALTY = 0.1
+```
+
+#### Ajuste de Pesos
+
+```python
+# Priorizar análise técnica
+ScoringConfig.TECHNICAL_WEIGHT = 0.6
+ScoringConfig.SENTIMENT_WEIGHT = 0.2
+ScoringConfig.FIBONACCI_WEIGHT = 0.2
+
+# Priorizar sentimento
+ScoringConfig.TECHNICAL_WEIGHT = 0.2
+ScoringConfig.SENTIMENT_WEIGHT = 0.6
+ScoringConfig.FIBONACCI_WEIGHT = 0.2
+```
+
+## 🚀 Configuração de Performance
+
+### Configurações de Sistema
+
+```python
+# Em performance_monitor.py
+class PerformanceConfig:
+    # Intervalo de coleta de métricas (segundos)
+    METRICS_INTERVAL = 5.0
+    
+    # Histórico máximo de métricas
+    MAX_METRICS_HISTORY = 1000
+    
+    # Thresholds de alerta
+    CPU_ALERT_THRESHOLD = 80.0
+    MEMORY_ALERT_THRESHOLD = 85.0
+    
+    # Configurações de otimização
+    ENABLE_AUTO_OPTIMIZATION = True
+    OPTIMIZATION_INTERVAL = 300  # 5 minutos
+```
+
+### Configurações de Cache
+
+```python
+# Cache de modelos
+MODEL_CACHE_SIZE = 3
+MODEL_CACHE_TTL = 3600  # 1 hora
+
+# Cache de análises
+ANALYSIS_CACHE_SIZE = 100
+ANALYSIS_CACHE_TTL = 300  # 5 minutos
+```
+
+## 🔧 Configuração via Variáveis de Ambiente
+
+### Variáveis Suportadas
+
+```bash
+# Modelo de IA
+export FINBERT_MODEL="ProsusAI/finbert"
+export MAX_TEXT_LENGTH="512"
+
+# Performance
+export MAX_WORKERS="4"
+export ENABLE_GPU="true"
+export CACHE_SIZE="1000"
+
+# Logging
+export LOG_LEVEL="INFO"
+export LOG_FILE="vampire_bot.log"
+
+# Interface
+export GRADIO_SERVER_NAME="0.0.0.0"
+export GRADIO_SERVER_PORT="7860"
+export GRADIO_SHARE="false"
+
+# Real-time
+export LOG_FILE_PATH="/path/to/trading.log"
+export CHECK_INTERVAL="1.0"
+```
+
+### Carregamento de Variáveis
+
+```python
+import os
+from config import AIConfig, UIConfig
+
+# Carregar configurações do ambiente
+AIConfig.MAX_TEXT_LENGTH = int(os.getenv('MAX_TEXT_LENGTH', '512'))
+AIConfig.USE_GPU = os.getenv('ENABLE_GPU', 'true').lower() == 'true'
+
+UIConfig.TITLE = os.getenv('APP_TITLE', UIConfig.TITLE)
+```
+
+## 📋 Configuração por Perfil
+
+### Perfis Pré-definidos
+
+```python
+# profiles.py
+class DevelopmentProfile:
+    """Perfil para desenvolvimento."""
+    DEBUG = True
+    LOG_LEVEL = "DEBUG"
+    ENABLE_MODEL_CACHE = False
+    USE_LIGHTWEIGHT_MODELS = True
+
+class ProductionProfile:
+    """Perfil para produção."""
+    DEBUG = False
+    LOG_LEVEL = "INFO"
+    ENABLE_MODEL_CACHE = True
+    USE_LIGHTWEIGHT_MODELS = False
+    ENABLE_MONITORING = True
+
+class TestingProfile:
+    """Perfil para testes."""
+    DEBUG = True
+    LOG_LEVEL = "WARNING"
+    USE_MOCK_MODELS = True
+    DISABLE_REAL_TIME = True
+```
+
+### Aplicação de Perfis
+
+```python
+# app.py
+import os
+from profiles import DevelopmentProfile, ProductionProfile
+
+profile = os.getenv('APP_PROFILE', 'development')
+
+if profile == 'production':
+    config = ProductionProfile()
+else:
+    config = DevelopmentProfile()
+
+# Aplicar configurações
+for attr in dir(config):
+    if not attr.startswith('_'):
+        setattr(globals()[attr.split('_')[0] + 'Config'], attr, getattr(config, attr))
+```
+
+## 🔄 Configuração Dinâmica
+
+### Recarregamento de Configuração
+
+```python
+class ConfigManager:
+    """Gerenciador de configuração dinâmica."""
+    
+    @staticmethod
+    def reload_config():
+        """Recarrega configurações do arquivo."""
+        importlib.reload(config)
+    
+    @staticmethod
+    def update_config(section: str, key: str, value: Any):
+        """Atualiza configuração específica."""
+        config_class = getattr(config, section)
+        setattr(config_class, key, value)
+    
+    @staticmethod
+    def get_config(section: str, key: str) -> Any:
+        """Obtém valor de configuração."""
+        config_class = getattr(config, section)
+        return getattr(config_class, key)
+```
+
+### Interface de Configuração
+
+```python
+# Adicionar à interface Gradio
+def create_config_interface():
+    with gr.Tab("⚙️ Configurações"):
+        with gr.Row():
+            model_dropdown = gr.Dropdown(
+                choices=FinancialModels.FINANCIAL_MODELS,
+                value=FinancialModels.DEFAULT_MODEL,
+                label="Modelo de IA"
+            )
+            
+        with gr.Row():
+            rsi_period = gr.Number(
+                value=TechnicalAnalysis.RSI_PERIOD,
+                label="Período RSI"
+            )
+            
+        update_btn = gr.Button("Atualizar Configurações")
+        
+        update_btn.click(
+            fn=update_configurations,
+            inputs=[model_dropdown, rsi_period],
+            outputs=[]
+        )
+```
+
+## 📝 Exemplos de Configuração
+
+### Configuração Básica
+
+```python
+# config_basic.py
+from config import *
+
+# Usar modelo leve
+FinancialModels.DEFAULT_MODEL = "nlptown/bert-base-multilingual-uncased-sentiment"
+
+# Configurações conservadoras
+TradingConfig.DEFAULT_STOP_LOSS = 0.3
+TradingConfig.MIN_RISK_REWARD = 2.0
+
+# Interface simples
+UIConfig.TITLE = "Bot de Trading Simples"
+```
+
+### Configuração Avançada
+
+```python
+# config_advanced.py
+from config import *
+
+# Usar modelo mais preciso
+FinancialModels.DEFAULT_MODEL = "ProsusAI/finbert"
+
+# Análise técnica mais sensível
+TechnicalAnalysis.RSI_PERIOD = 10
+TechnicalAnalysis.EMA_FAST_PERIOD = 5
+
+# Trading mais agressivo
+TradingConfig.DEFAULT_STOP_LOSS = 0.8
+TradingConfig.MIN_RISK_REWARD = 1.2
+
+# Performance otimizada
+AIConfig.BATCH_SIZE = 16
+AIConfig.ENABLE_MODEL_CACHE = True
+```
+
+## 🔍 Troubleshooting de Configuração
+
+### Problemas Comuns
+
+1. **Modelo não carrega**:
+   ```python
+   # Verificar se modelo existe
+   try:
+       from transformers import pipeline
+       pipeline("sentiment-analysis", model=FinancialModels.DEFAULT_MODEL)
+   except Exception as e:
+       print(f"Erro ao carregar modelo: {e}")
+   ```
+
+2. **Configuração não aplicada**:
+   ```python
+   # Verificar se configuração foi carregada
+   print(f"Modelo atual: {FinancialModels.DEFAULT_MODEL}")
+   print(f"RSI período: {TechnicalAnalysis.RSI_PERIOD}")
+   ```
+
+3. **Performance baixa**:
+   ```python
+   # Configurações para melhor performance
+   AIConfig.MAX_TEXT_LENGTH = 256
+   AIConfig.BATCH_SIZE = 4
+   AIConfig.USE_GPU = False
+   ```
+
+### Validação de Configuração
+
+```python
+def validate_config():
+    """Valida configurações atuais."""
+    errors = []
+    
+    # Validar modelo
+    if FinancialModels.DEFAULT_MODEL not in FinancialModels.FINANCIAL_MODELS:
+        errors.append("Modelo padrão não está na lista de modelos")
+    
+    # Validar períodos
+    if TechnicalAnalysis.RSI_PERIOD < 2:
+        errors.append("Período RSI muito baixo")
+    
+    # Validar trading
+    if TradingConfig.DEFAULT_STOP_LOSS <= 0:
+        errors.append("Stop loss deve ser positivo")
+    
+    return errors
+```
+
+## 📚 Próximos Passos
+
+- Leia o [Guia do Desenvolvedor](developer-guide.md)
+- Consulte a [Referência da API](api-reference.md)
+- Veja exemplos em [Troubleshooting](troubleshooting.md)

docs/developer-guide.md

@@ -0,0 +1,963 @@
+# 👨‍💻 Guia do Desenvolvedor
+
+## Visão Geral
+
+Este guia fornece informações essenciais para desenvolvedores que desejam contribuir ou estender o Vampire Trading Bot. Inclui padrões de código, arquitetura, fluxos de desenvolvimento e melhores práticas.
+
+## 🏗️ Arquitetura do Sistema
+
+### Estrutura Modular
+
+```
+vampire-trading-bot/
+├── app.py                 # Ponto de entrada principal
+├── config.py             # Configurações centralizadas
+├── ui.py                 # Interface Gradio
+├── market_analysis.py    # Análise técnica
+├── sentiment_analysis.py # Análise de sentimento
+├── fibonacci_analysis.py # Análise de Fibonacci
+├── log_parser.py        # Parser de logs
+├── real_time_integration.py # Integração tempo real
+├── performance_monitor.py   # Monitoramento
+├── utils.py             # Utilitários
+├── docs/                # Documentação
+└── tests/               # Testes automatizados
+```
+
+### Princípios de Design
+
+1. **Separação de Responsabilidades**: Cada módulo tem uma função específica
+2. **Baixo Acoplamento**: Módulos independentes com interfaces bem definidas
+3. **Alta Coesão**: Funcionalidades relacionadas agrupadas
+4. **Extensibilidade**: Fácil adição de novos recursos
+5. **Testabilidade**: Código facilmente testável
+
+## 🔧 Configuração do Ambiente de Desenvolvimento
+
+### Pré-requisitos
+
+```bash
+# Python 3.8+
+python --version
+
+# Git
+git --version
+
+# Editor recomendado: VS Code com extensões Python
+```
+
+### Setup Inicial
+
+```bash
+# 1. Clonar repositório
+git clone <repository-url>
+cd vampire-trading-bot
+
+# 2. Criar ambiente virtual
+python -m venv venv
+
+# 3. Ativar ambiente
+# Windows
+venv\Scripts\activate
+# Linux/macOS
+source venv/bin/activate
+
+# 4. Instalar dependências de desenvolvimento
+pip install -r requirements-dev.txt
+
+# 5. Instalar hooks de pre-commit
+pre-commit install
+```
+
+### Dependências de Desenvolvimento
+
+```txt
+# requirements-dev.txt
+pytest>=7.0.0
+pytest-cov>=4.0.0
+black>=22.0.0
+flake8>=5.0.0
+mypy>=1.0.0
+pre-commit>=2.20.0
+bandit>=1.7.0
+isort>=5.10.0
+memory-profiler>=0.60.0
+line-profiler>=4.0.0
+```
+
+## 📝 Padrões de Código
+
+### Estilo de Código
+
+**Formatação com Black**:
+```bash
+# Formatar código
+black .
+
+# Verificar formatação
+black --check .
+```
+
+**Linting com Flake8**:
+```bash
+# Verificar código
+flake8 .
+
+# Configuração em .flake8
+[flake8]
+max-line-length = 88
+ignore = E203, W503
+exclude = venv, __pycache__
+```
+
+**Ordenação de Imports com isort**:
+```bash
+# Ordenar imports
+isort .
+
+# Configuração em pyproject.toml
+[tool.isort]
+profile = "black"
+line_length = 88
+```
+
+### Convenções de Nomenclatura
+
+```python
+# Classes: PascalCase
+class TechnicalAnalysisEngine:
+    pass
+
+# Funções e variáveis: snake_case
+def calculate_rsi_value(prices: List[float]) -> float:
+    pass
+
+# Constantes: UPPER_SNAKE_CASE
+DEFAULT_RSI_PERIOD = 14
+MAX_RETRY_ATTEMPTS = 3
+
+# Arquivos: snake_case
+# market_analysis.py
+# sentiment_analysis.py
+```
+
+### Documentação de Código
+
+```python
+def analyze_market_data(
+    self, 
+    text: str, 
+    include_fibonacci: bool = True
+) -> Dict[str, Any]:
+    """
+    Analisa dados de mercado extraindo indicadores técnicos.
+    
+    Args:
+        text: Texto contendo dados de mercado
+        include_fibonacci: Se deve incluir análise de Fibonacci
+        
+    Returns:
+        Dict contendo:
+        - technical_signals: Lista de sinais técnicos
+        - market_data: Dados extraídos do mercado
+        - fibonacci_analysis: Análise de Fibonacci (se habilitada)
+        
+    Raises:
+        ValueError: Se o texto não contém dados válidos
+        RuntimeError: Se falha na análise técnica
+        
+    Example:
+        >>> engine = TechnicalAnalysisEngine()
+        >>> result = engine.analyze_market_data("WINV25: 140135")
+        >>> print(result['technical_signals'])
+    """
+    pass
+```
+
+### Type Hints
+
+```python
+from typing import List, Dict, Optional, Union, Tuple, Any
+from dataclasses import dataclass
+from enum import Enum
+
+# Usar type hints em todas as funções
+def calculate_ema(
+    prices: List[float], 
+    period: int
+) -> List[float]:
+    pass
+
+# Dataclasses para estruturas de dados
+@dataclass
+class MarketData:
+    symbol: str
+    price: float
+    volume: int
+    timestamp: Optional[str] = None
+
+# Enums para constantes
+class SignalType(Enum):
+    BUY = "buy"
+    SELL = "sell"
+    HOLD = "hold"
+```
+
+## 🧪 Testes
+
+### Estrutura de Testes
+
+```
+tests/
+├── __init__.py
+├── conftest.py              # Fixtures compartilhadas
+├── test_market_analysis.py  # Testes análise técnica
+├── test_sentiment_analysis.py # Testes análise sentimento
+├── test_fibonacci_analysis.py # Testes Fibonacci
+├── test_integration.py      # Testes integração
+├── test_performance.py      # Testes performance
+└── fixtures/               # Dados de teste
+    ├── sample_logs.txt
+    └── market_data.json
+```
+
+### Escrevendo Testes
+
+```python
+# test_market_analysis.py
+import pytest
+from unittest.mock import Mock, patch
+from market_analysis import TechnicalAnalysisEngine, MarketData
+
+class TestTechnicalAnalysisEngine:
+    
+    @pytest.fixture
+    def engine(self):
+        """Fixture para engine de análise."""
+        return TechnicalAnalysisEngine()
+    
+    @pytest.fixture
+    def sample_market_data(self):
+        """Fixture para dados de mercado."""
+        return MarketData(
+            symbol="WINV25",
+            price=140135.0,
+            volume=5023
+        )
+    
+    def test_analyze_market_data_success(self, engine, sample_market_data):
+        """Testa análise bem-sucedida de dados de mercado."""
+        text = "WINV25: 140135, Volume: 5023"
+        
+        result = engine.analyze_market_data(text)
+        
+        assert "technical_signals" in result
+        assert "market_data" in result
+        assert len(result["technical_signals"]) > 0
+    
+    def test_analyze_market_data_invalid_input(self, engine):
+        """Testa comportamento com entrada inválida."""
+        with pytest.raises(ValueError, match="Dados inválidos"):
+            engine.analyze_market_data("")
+    
+    @patch('market_analysis.calculate_rsi')
+    def test_rsi_calculation_called(self, mock_rsi, engine):
+        """Testa se cálculo RSI é chamado."""
+        mock_rsi.return_value = 65.5
+        text = "WINV25: 140135"
+        
+        engine.analyze_market_data(text)
+        
+        mock_rsi.assert_called_once()
+    
+    @pytest.mark.parametrize("price,expected_signal", [
+        (140000, "buy"),
+        (145000, "sell"),
+        (142500, "hold")
+    ])
+    def test_signal_generation(self, engine, price, expected_signal):
+        """Testa geração de sinais para diferentes preços."""
+        text = f"WINV25: {price}"
+        
+        result = engine.analyze_market_data(text)
+        signal = result["technical_signals"][0]
+        
+        assert signal["action"] == expected_signal
+```
+
+### Executando Testes
+
+```bash
+# Executar todos os testes
+pytest
+
+# Executar com cobertura
+pytest --cov=. --cov-report=html
+
+# Executar testes específicos
+pytest tests/test_market_analysis.py::TestTechnicalAnalysisEngine::test_analyze_market_data_success
+
+# Executar testes em paralelo
+pytest -n auto
+
+# Executar apenas testes rápidos
+pytest -m "not slow"
+```
+
+### Fixtures Compartilhadas
+
+```python
+# conftest.py
+import pytest
+from pathlib import Path
+
+@pytest.fixture
+def sample_log_content():
+    """Conteúdo de log de exemplo."""
+    return """
+    ⏰ Análise #1 - 09:46:58
+    📊 DADOS DE MERCADO - WINV25
+    Preço Atual: 140135.00000 ↗
+    Variação: +5 (+0.00%)
+    Volume: 5023
+    """
+
+@pytest.fixture
+def temp_log_file(tmp_path, sample_log_content):
+    """Arquivo de log temporário."""
+    log_file = tmp_path / "test_log.txt"
+    log_file.write_text(sample_log_content)
+    return log_file
+
+@pytest.fixture
+def mock_ai_model():
+    """Mock do modelo de IA."""
+    from unittest.mock import Mock
+    
+    model = Mock()
+    model.predict.return_value = [
+        {"label": "POSITIVE", "score": 0.85}
+    ]
+    return model
+```
+
+## 🔄 Fluxo de Desenvolvimento
+
+### Git Workflow
+
+```bash
+# 1. Criar branch para feature
+git checkout -b feature/nova-funcionalidade
+
+# 2. Fazer commits pequenos e frequentes
+git add .
+git commit -m "feat: adiciona cálculo de MACD"
+
+# 3. Push da branch
+git push origin feature/nova-funcionalidade
+
+# 4. Criar Pull Request
+# 5. Code Review
+# 6. Merge após aprovação
+```
+
+### Convenções de Commit
+
+```bash
+# Formato: tipo(escopo): descrição
+
+# Tipos:
+feat: nova funcionalidade
+fix: correção de bug
+docs: documentação
+style: formatação
+refactor: refatoração
+test: testes
+chore: tarefas de manutenção
+
+# Exemplos:
+feat(analysis): adiciona indicador MACD
+fix(ui): corrige erro na interface
+docs(api): atualiza documentação da API
+test(fibonacci): adiciona testes para análise
+```
+
+### Pre-commit Hooks
+
+```yaml
+# .pre-commit-config.yaml
+repos:
+  - repo: https://github.com/psf/black
+    rev: 22.10.0
+    hooks:
+      - id: black
+        language_version: python3
+
+  - repo: https://github.com/pycqa/flake8
+    rev: 5.0.4
+    hooks:
+      - id: flake8
+
+  - repo: https://github.com/pycqa/isort
+    rev: 5.10.1
+    hooks:
+      - id: isort
+
+  - repo: https://github.com/pre-commit/mirrors-mypy
+    rev: v0.991
+    hooks:
+      - id: mypy
+        additional_dependencies: [types-all]
+
+  - repo: https://github.com/PyCQA/bandit
+    rev: 1.7.4
+    hooks:
+      - id: bandit
+        args: ['-r', '.', '-f', 'json', '-o', 'bandit-report.json']
+```
+
+## 🏗️ Adicionando Novas Funcionalidades
+
+### 1. Novo Indicador Técnico
+
+```python
+# Em market_analysis.py
+
+class MACDAnalyzer(BaseAnalyzer):
+    """Analisador MACD (Moving Average Convergence Divergence)."""
+    
+    def __init__(self, fast_period: int = 12, slow_period: int = 26, signal_period: int = 9):
+        self.fast_period = fast_period
+        self.slow_period = slow_period
+        self.signal_period = signal_period
+    
+    def analyze(self, prices: List[float]) -> List[TechnicalSignal]:
+        """Calcula MACD e gera sinais."""
+        if len(prices) < self.slow_period:
+            return []
+        
+        # Calcular EMAs
+        ema_fast = self._calculate_ema(prices, self.fast_period)
+        ema_slow = self._calculate_ema(prices, self.slow_period)
+        
+        # Calcular MACD
+        macd_line = [fast - slow for fast, slow in zip(ema_fast, ema_slow)]
+        signal_line = self._calculate_ema(macd_line, self.signal_period)
+        
+        # Gerar sinais
+        signals = []
+        for i in range(1, len(macd_line)):
+            if macd_line[i] > signal_line[i] and macd_line[i-1] <= signal_line[i-1]:
+                signals.append(TechnicalSignal(
+                    indicator="MACD",
+                    signal_type="buy",
+                    strength=0.7,
+                    value=macd_line[i],
+                    timestamp=datetime.now()
+                ))
+        
+        return signals
+
+# Registrar no engine
+class TechnicalAnalysisEngine:
+    def __init__(self):
+        # ... outros analisadores
+        self.macd_analyzer = MACDAnalyzer()
+    
+    def analyze_market_data(self, text: str) -> Dict[str, Any]:
+        # ... análise existente
+        macd_signals = self.macd_analyzer.analyze(prices)
+        all_signals.extend(macd_signals)
+```
+
+### 2. Novo Modelo de IA
+
+```python
+# Em sentiment_analysis.py
+
+class CustomFinancialModel:
+    """Modelo personalizado para análise financeira."""
+    
+    def __init__(self, model_path: str):
+        self.model_path = model_path
+        self.model = None
+        self.tokenizer = None
+    
+    def load(self):
+        """Carrega modelo personalizado."""
+        from transformers import AutoTokenizer, AutoModelForSequenceClassification
+        
+        self.tokenizer = AutoTokenizer.from_pretrained(self.model_path)
+        self.model = AutoModelForSequenceClassification.from_pretrained(self.model_path)
+    
+    def predict(self, text: str) -> Dict[str, float]:
+        """Faz predição de sentimento."""
+        inputs = self.tokenizer(text, return_tensors="pt", truncation=True, padding=True)
+        
+        with torch.no_grad():
+            outputs = self.model(**inputs)
+            probabilities = torch.nn.functional.softmax(outputs.logits, dim=-1)
+        
+        return {
+            "bullish": probabilities[0][0].item(),
+            "bearish": probabilities[0][1].item(),
+            "neutral": probabilities[0][2].item()
+        }
+
+# Registrar no ModelManager
+class ModelManager:
+    def __init__(self):
+        # ... modelos existentes
+        self.custom_models = {
+            "financial-bert": CustomFinancialModel,
+            "trading-roberta": CustomFinancialModel
+        }
+```
+
+### 3. Nova Interface de Usuário
+
+```python
+# Em ui.py
+
+def create_advanced_analysis_tab():
+    """Cria aba de análise avançada."""
+    with gr.Tab("🔬 Análise Avançada"):
+        with gr.Row():
+            with gr.Column(scale=1):
+                # Controles
+                timeframe_dropdown = gr.Dropdown(
+                    choices=["1m", "5m", "15m", "1h", "4h", "1d"],
+                    value="5m",
+                    label="📊 Timeframe"
+                )
+                
+                indicators_checklist = gr.CheckboxGroup(
+                    choices=["RSI", "MACD", "Bollinger", "EMA", "Fibonacci"],
+                    value=["RSI", "MACD"],
+                    label="📈 Indicadores"
+                )
+                
+                analyze_btn = gr.Button("🚀 Analisar", variant="primary")
+            
+            with gr.Column(scale=2):
+                # Resultados
+                analysis_output = gr.JSON(label="📊 Resultado da Análise")
+                chart_output = gr.Plot(label="📈 Gráfico")
+        
+        # Conectar eventos
+        analyze_btn.click(
+            fn=advanced_analysis,
+            inputs=[timeframe_dropdown, indicators_checklist],
+            outputs=[analysis_output, chart_output]
+        )
+    
+    return timeframe_dropdown, indicators_checklist, analyze_btn
+
+def advanced_analysis(timeframe: str, indicators: List[str]) -> Tuple[Dict, Any]:
+    """Executa análise avançada."""
+    # Implementar lógica de análise
+    result = {
+        "timeframe": timeframe,
+        "indicators": indicators,
+        "signals": [],
+        "confidence": 0.0
+    }
+    
+    # Gerar gráfico
+    import plotly.graph_objects as go
+    fig = go.Figure()
+    # ... adicionar dados ao gráfico
+    
+    return result, fig
+```
+
+## 🔍 Debugging e Profiling
+
+### Logging para Debug
+
+```python
+import logging
+from utils import LogUtils
+
+# Configurar logging detalhado
+logging.basicConfig(
+    level=logging.DEBUG,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('debug.log'),
+        logging.StreamHandler()
+    ]
+)
+
+logger = logging.getLogger(__name__)
+
+def analyze_market_data(self, text: str) -> Dict[str, Any]:
+    logger.debug(f"Iniciando análise para texto: {text[:100]}...")
+    
+    try:
+        # Análise
+        result = self._perform_analysis(text)
+        logger.debug(f"Análise concluída: {len(result.get('signals', []))} sinais")
+        return result
+        
+    except Exception as e:
+        logger.error(f"Erro na análise: {e}", exc_info=True)
+        raise
+```
+
+### Profiling de Performance
+
+```python
+# performance_profiler.py
+import cProfile
+import pstats
+from functools import wraps
+from memory_profiler import profile
+from line_profiler import LineProfiler
+
+def profile_time(func):
+    """Decorator para profiling de tempo."""
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        profiler = cProfile.Profile()
+        profiler.enable()
+        
+        result = func(*args, **kwargs)
+        
+        profiler.disable()
+        stats = pstats.Stats(profiler)
+        stats.sort_stats('cumulative')
+        stats.print_stats(10)  # Top 10 funções
+        
+        return result
+    return wrapper
+
+@profile_time
+@profile  # memory_profiler
+def analyze_large_dataset(data):
+    """Análise de dataset grande."""
+    # Implementação
+    pass
+
+# Usar line_profiler
+def profile_line_by_line():
+    profiler = LineProfiler()
+    profiler.add_function(analyze_market_data)
+    profiler.enable_by_count()
+    
+    # Executar função
+    analyze_market_data(sample_text)
+    
+    profiler.print_stats()
+```
+
+### Debugging com pdb
+
+```python
+import pdb
+
+def problematic_function(data):
+    # Ponto de breakpoint
+    pdb.set_trace()
+    
+    # Código para debug
+    processed_data = process_data(data)
+    
+    # Breakpoint condicional
+    if len(processed_data) == 0:
+        pdb.set_trace()
+    
+    return processed_data
+
+# Comandos úteis no pdb:
+# l - listar código
+# n - próxima linha
+# s - step into
+# c - continuar
+# p variable - imprimir variável
+# pp variable - pretty print
+# h - ajuda
+```
+
+## 📊 Monitoramento e Métricas
+
+### Métricas Customizadas
+
+```python
+# custom_metrics.py
+from dataclasses import dataclass
+from typing import Dict, List
+import time
+from collections import defaultdict
+
+@dataclass
+class AnalysisMetrics:
+    """Métricas de análise."""
+    total_analyses: int = 0
+    successful_analyses: int = 0
+    failed_analyses: int = 0
+    average_processing_time: float = 0.0
+    error_types: Dict[str, int] = None
+    
+    def __post_init__(self):
+        if self.error_types is None:
+            self.error_types = defaultdict(int)
+
+class MetricsCollector:
+    """Coletor de métricas personalizado."""
+    
+    def __init__(self):
+        self.metrics = AnalysisMetrics()
+        self.processing_times = []
+    
+    def record_analysis_start(self) -> float:
+        """Registra início de análise."""
+        return time.time()
+    
+    def record_analysis_success(self, start_time: float):
+        """Registra análise bem-sucedida."""
+        processing_time = time.time() - start_time
+        
+        self.metrics.total_analyses += 1
+        self.metrics.successful_analyses += 1
+        self.processing_times.append(processing_time)
+        
+        # Calcular média móvel
+        if len(self.processing_times) > 100:
+            self.processing_times = self.processing_times[-100:]
+        
+        self.metrics.average_processing_time = sum(self.processing_times) / len(self.processing_times)
+    
+    def record_analysis_failure(self, start_time: float, error_type: str):
+        """Registra falha na análise."""
+        self.metrics.total_analyses += 1
+        self.metrics.failed_analyses += 1
+        self.metrics.error_types[error_type] += 1
+    
+    def get_success_rate(self) -> float:
+        """Calcula taxa de sucesso."""
+        if self.metrics.total_analyses == 0:
+            return 0.0
+        return self.metrics.successful_analyses / self.metrics.total_analyses
+    
+    def export_metrics(self) -> Dict:
+        """Exporta métricas para análise."""
+        return {
+            "total_analyses": self.metrics.total_analyses,
+            "success_rate": self.get_success_rate(),
+            "average_processing_time": self.metrics.average_processing_time,
+            "error_distribution": dict(self.metrics.error_types)
+        }
+```
+
+## 🚀 Deploy e Produção
+
+### Configuração para Produção
+
+```python
+# production_config.py
+import os
+from dataclasses import dataclass
+
+@dataclass
+class ProductionConfig:
+    """Configurações para produção."""
+    
+    # Servidor
+    HOST: str = os.getenv("HOST", "0.0.0.0")
+    PORT: int = int(os.getenv("PORT", "7860"))
+    WORKERS: int = int(os.getenv("WORKERS", "4"))
+    
+    # Logging
+    LOG_LEVEL: str = os.getenv("LOG_LEVEL", "INFO")
+    LOG_FILE: str = os.getenv("LOG_FILE", "app.log")
+    
+    # Performance
+    MAX_CONCURRENT_ANALYSES: int = int(os.getenv("MAX_CONCURRENT_ANALYSES", "10"))
+    ANALYSIS_TIMEOUT: int = int(os.getenv("ANALYSIS_TIMEOUT", "30"))
+    
+    # Segurança
+    ENABLE_AUTH: bool = os.getenv("ENABLE_AUTH", "false").lower() == "true"
+    SECRET_KEY: str = os.getenv("SECRET_KEY", "")
+    
+    # Cache
+    ENABLE_REDIS: bool = os.getenv("ENABLE_REDIS", "false").lower() == "true"
+    REDIS_URL: str = os.getenv("REDIS_URL", "redis://localhost:6379")
+```
+
+### Docker
+
+```dockerfile
+# Dockerfile
+FROM python:3.9-slim
+
+# Instalar dependências do sistema
+RUN apt-get update && apt-get install -y \
+    gcc \
+    g++ \
+    && rm -rf /var/lib/apt/lists/*
+
+# Criar usuário não-root
+RUN useradd --create-home --shell /bin/bash app
+USER app
+WORKDIR /home/app
+
+# Copiar requirements
+COPY --chown=app:app requirements.txt .
+
+# Instalar dependências Python
+RUN pip install --user --no-cache-dir -r requirements.txt
+
+# Copiar código
+COPY --chown=app:app . .
+
+# Expor porta
+EXPOSE 7860
+
+# Comando de inicialização
+CMD ["python", "app.py", "--host", "0.0.0.0", "--port", "7860"]
+```
+
+```yaml
+# docker-compose.yml
+version: '3.8'
+
+services:
+  vampire-bot:
+    build: .
+    ports:
+      - "7860:7860"
+    environment:
+      - LOG_LEVEL=INFO
+      - MAX_CONCURRENT_ANALYSES=5
+    volumes:
+      - ./logs:/home/app/logs
+      - ./models:/home/app/models
+    restart: unless-stopped
+    
+  redis:
+    image: redis:7-alpine
+    ports:
+      - "6379:6379"
+    volumes:
+      - redis_data:/data
+    restart: unless-stopped
+
+volumes:
+  redis_data:
+```
+
+## 📚 Recursos Adicionais
+
+### Ferramentas Recomendadas
+
+- **IDE**: VS Code com extensões Python
+- **Debugging**: pdb, ipdb, VS Code debugger
+- **Profiling**: cProfile, memory_profiler, line_profiler
+- **Testing**: pytest, coverage.py
+- **Linting**: flake8, pylint, mypy
+- **Formatting**: black, isort
+- **Documentation**: Sphinx, mkdocs
+
+### Bibliotecas Úteis
+
+```python
+# Análise de dados
+import pandas as pd
+import numpy as np
+from scipy import stats
+
+# Visualização
+import matplotlib.pyplot as plt
+import plotly.graph_objects as go
+import seaborn as sns
+
+# Machine Learning
+from sklearn.metrics import accuracy_score, classification_report
+from sklearn.model_selection import train_test_split
+
+# Async/Concorrência
+import asyncio
+from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
+
+# Monitoramento
+import psutil
+from prometheus_client import Counter, Histogram, Gauge
+```
+
+### Padrões de Design Úteis
+
+```python
+# Strategy Pattern para diferentes análises
+from abc import ABC, abstractmethod
+
+class AnalysisStrategy(ABC):
+    @abstractmethod
+    def analyze(self, data) -> Dict:
+        pass
+
+class RSIStrategy(AnalysisStrategy):
+    def analyze(self, data) -> Dict:
+        # Implementar RSI
+        pass
+
+class MACDStrategy(AnalysisStrategy):
+    def analyze(self, data) -> Dict:
+        # Implementar MACD
+        pass
+
+# Factory Pattern para criação de analisadores
+class AnalyzerFactory:
+    _strategies = {
+        "rsi": RSIStrategy,
+        "macd": MACDStrategy
+    }
+    
+    @classmethod
+    def create_analyzer(cls, analyzer_type: str) -> AnalysisStrategy:
+        if analyzer_type not in cls._strategies:
+            raise ValueError(f"Analisador {analyzer_type} não suportado")
+        return cls._strategies[analyzer_type]()
+
+# Observer Pattern para notificações
+class Observable:
+    def __init__(self):
+        self._observers = []
+    
+    def attach(self, observer):
+        self._observers.append(observer)
+    
+    def notify(self, event):
+        for observer in self._observers:
+            observer.update(event)
+```
+
+## 🤝 Contribuindo
+
+### Processo de Contribuição
+
+1. **Fork** do repositório
+2. **Clone** do seu fork
+3. **Criar branch** para feature/bugfix
+4. **Implementar** mudanças com testes
+5. **Executar** testes e linting
+6. **Commit** seguindo convenções
+7. **Push** da branch
+8. **Criar Pull Request**
+9. **Code Review**
+10. **Merge** após aprovação
+
+### Checklist para Pull Requests
+
+- [ ] Código segue padrões de estilo
+- [ ] Testes adicionados/atualizados
+- [ ] Documentação atualizada
+- [ ] Todos os testes passam
+- [ ] Sem warnings de linting
+- [ ] Performance não degradada
+- [ ] Compatibilidade mantida
+- [ ] Changelog atualizado
+
+---
+
+**🎯 Objetivo**: Manter código limpo, testável e bem documentado para facilitar manutenção e evolução do projeto!

docs/installation.md

@@ -0,0 +1,216 @@
+# 🚀 Guia de Instalação
+
+## Pré-requisitos
+
+### Sistema Operacional
+- Windows 10/11 (recomendado)
+- Linux (Ubuntu 20.04+)
+- macOS (10.15+)
+
+### Software Necessário
+- **Python 3.13+** (obrigatório)
+- **Git** (para clonagem do repositório)
+- **Visual Studio Build Tools** (Windows - para compilação de dependências)
+
+## Instalação Passo a Passo
+
+### 1. Preparação do Ambiente
+
+#### Windows
+```powershell
+# Verificar versão do Python
+python --version
+
+# Instalar Visual Studio Build Tools (se necessário)
+# Baixar de: https://visualstudio.microsoft.com/visual-cpp-build-tools/
+```
+
+#### Linux/macOS
+```bash
+# Verificar versão do Python
+python3 --version
+
+# Instalar dependências do sistema (Ubuntu)
+sudo apt update
+sudo apt install python3-pip python3-venv build-essential
+```
+
+### 2. Clonagem do Repositório
+
+```bash
+git clone <repository-url>
+cd vampire-trading-bot
+```
+
+### 3. Criação do Ambiente Virtual
+
+#### Windows
+```powershell
+# Criar ambiente virtual
+python -m venv venv
+
+# Ativar ambiente virtual
+.\venv\Scripts\Activate.ps1
+```
+
+#### Linux/macOS
+```bash
+# Criar ambiente virtual
+python3 -m venv venv
+
+# Ativar ambiente virtual
+source venv/bin/activate
+```
+
+### 4. Instalação das Dependências
+
+```bash
+# Atualizar pip
+pip install --upgrade pip
+
+# Instalar dependências principais
+pip install -r requirements.txt
+```
+
+#### Dependências Principais
+- `gradio==4.44.0` - Interface web
+- `transformers` - Modelos de IA
+- `torch` - Framework de deep learning
+- `numpy` - Computação numérica
+- `pandas` - Manipulação de dados
+- `scipy` - Computação científica
+- `psutil` - Monitoramento de sistema
+
+### 5. Verificação da Instalação
+
+```bash
+# Testar importações principais
+python -c "import gradio, transformers, torch, numpy, pandas; print('✅ Todas as dependências instaladas com sucesso!')"
+
+# Executar aplicação em modo de teste
+python app.py
+```
+
+## Resolução de Problemas Comuns
+
+### Erro de Compilação do Rust (tokenizers)
+
+**Problema**: Erro ao instalar `tokenizers` devido à falta do Rust
+
+**Solução**:
+```bash
+# Instalar versão mais recente do transformers
+pip install --upgrade transformers
+
+# Ou instalar Rust (alternativa)
+curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
+```
+
+### Erro do pyaudioop (Python 3.13)
+
+**Problema**: `ModuleNotFoundError: No module named 'pyaudioop'`
+
+**Solução**:
+```bash
+# Atualizar Gradio para versão mais recente
+pip install --upgrade gradio
+
+# O audioop-lts será instalado automaticamente
+```
+
+### Problemas de Memória
+
+**Problema**: Erro de memória ao carregar modelos de IA
+
+**Solução**:
+- Usar modelos menores (configurar em `config.py`)
+- Aumentar memória virtual do sistema
+- Executar em modo standalone (sem IA)
+
+### Problemas de Permissão (Windows)
+
+**Problema**: Erro de permissão ao executar scripts
+
+**Solução**:
+```powershell
+# Alterar política de execução
+Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
+```
+
+## Configuração Inicial
+
+### 1. Configurar Modelos de IA
+
+Edite o arquivo `config.py`:
+
+```python
+# Modelos disponíveis (do menor para o maior)
+FINANCIAL_MODELS = [
+    "nlptown/bert-base-multilingual-uncased-sentiment",  # Mais leve
+    "cardiffnlp/twitter-roberta-base-sentiment-latest",   # Médio
+    "ProsusAI/finbert"  # Mais pesado, melhor precisão
+]
+```
+
+### 2. Configurar Caminhos de Log
+
+Para integração em tempo real, configure o caminho dos logs:
+
+```python
+# Em real_time_integration.py
+LOG_FILE_PATH = "caminho/para/seus/logs/trading.log"
+```
+
+### 3. Configurar Interface
+
+Personalize a interface em `config.py`:
+
+```python
+class UIConfig:
+    TITLE = "Seu Título Personalizado"
+    SUBTITLE = "Sua Descrição"
+    # ... outras configurações
+```
+
+## Execução
+
+### Modo Desenvolvimento
+```bash
+# Executar com reload automático
+python app.py
+```
+
+### Modo Produção
+```bash
+# Executar com configurações otimizadas
+python app.py --share=False --server_name=0.0.0.0 --server_port=7860
+```
+
+### Modo Standalone (Sem IA)
+```bash
+# Executar sem dependências de IA
+python app.py --no-ai
+```
+
+## Verificação Final
+
+Após a instalação, verifique se:
+
+1. ✅ O aplicativo inicia sem erros
+2. ✅ A interface web carrega em `http://localhost:7860`
+3. ✅ As análises técnicas funcionam
+4. ✅ Os modelos de IA carregam (se disponíveis)
+5. ✅ O monitoramento de performance está ativo
+
+## Próximos Passos
+
+- Leia a [Documentação da Arquitetura](architecture.md)
+- Configure suas preferências em [Configuração](configuration.md)
+- Explore a [Referência da API](api-reference.md)
+
+## Suporte
+
+Para problemas não cobertos neste guia, consulte:
+- [Troubleshooting](troubleshooting.md)
+- [Issues do GitHub](link-para-issues)
+- Documentação oficial das dependências

docs/troubleshooting.md

@@ -0,0 +1,679 @@
+# 🔧 Guia de Troubleshooting
+
+## Visão Geral
+
+Este guia ajuda a resolver problemas comuns encontrados ao usar o Vampire Trading Bot. Os problemas estão organizados por categoria com soluções passo a passo.
+
+## 🚨 Problemas de Instalação
+
+### Erro: "Microsoft Visual C++ 14.0 is required"
+
+**Sintomas**:
+```
+error: Microsoft Visual C++ 14.0 is required. Get it with "Microsoft Visual C++ Build Tools"
+```
+
+**Causa**: Falta de ferramentas de compilação no Windows.
+
+**Solução**:
+1. Baixe e instale o [Visual Studio Build Tools](https://visualstudio.microsoft.com/visual-cpp-build-tools/)
+2. Durante a instalação, selecione "C++ build tools"
+3. Reinicie o terminal e tente novamente:
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+### Erro: "No module named 'pyaudioop'"
+
+**Sintomas**:
+```
+ModuleNotFoundError: No module named 'pyaudioop'
+```
+
+**Causa**: Incompatibilidade com Python 3.13.
+
+**Solução**:
+```bash
+# Atualizar Gradio para versão mais recente
+pip install --upgrade gradio
+
+# Verificar se audioop-lts foi instalado
+pip list | grep audioop
+```
+
+### Erro: "Failed building wheel for tokenizers"
+
+**Sintomas**:
+```
+Failed building wheel for tokenizers
+ERROR: Could not build wheels for tokenizers
+```
+
+**Causa**: Falta do compilador Rust.
+
+**Soluções**:
+
+**Opção 1 - Usar versão pré-compilada**:
+```bash
+pip install --upgrade transformers
+```
+
+**Opção 2 - Instalar Rust**:
+```bash
+# Windows (PowerShell)
+Invoke-WebRequest -Uri https://win.rustup.rs/ -OutFile rustup-init.exe
+.\rustup-init.exe
+
+# Linux/macOS
+curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
+source ~/.cargo/env
+```
+
+### Erro: "Permission denied" (Windows)
+
+**Sintomas**:
+```
+PermissionError: [WinError 5] Access is denied
+```
+
+**Solução**:
+```powershell
+# Alterar política de execução
+Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
+
+# Executar como administrador se necessário
+```
+
+## 🤖 Problemas com Modelos de IA
+
+### Erro: "OutOfMemoryError" ao carregar modelo
+
+**Sintomas**:
+```
+torch.cuda.OutOfMemoryError: CUDA out of memory
+# ou
+RuntimeError: [enforce fail at alloc_cpu.cpp:75]
+```
+
+**Soluções**:
+
+**1. Usar modelo mais leve**:
+```python
+# Em config.py
+FinancialModels.DEFAULT_MODEL = "nlptown/bert-base-multilingual-uncased-sentiment"
+```
+
+**2. Reduzir tamanho do texto**:
+```python
+# Em config.py
+AIConfig.MAX_TEXT_LENGTH = 256  # Reduzir de 512
+AIConfig.BATCH_SIZE = 4         # Reduzir de 8
+```
+
+**3. Forçar uso de CPU**:
+```python
+# Em config.py
+AIConfig.USE_GPU = False
+```
+
+**4. Executar em modo standalone**:
+```bash
+python app.py --no-ai
+```
+
+### Erro: "Model not found" ou "Repository not found"
+
+**Sintomas**:
+```
+OSError: Repository not found
+HTTPError: 404 Client Error
+```
+
+**Soluções**:
+
+**1. Verificar conectividade**:
+```python
+import requests
+response = requests.get("https://huggingface.co")
+print(f"Status: {response.status_code}")
+```
+
+**2. Usar modelo alternativo**:
+```python
+# Em config.py
+FinancialModels.DEFAULT_MODEL = "cardiffnlp/twitter-roberta-base-sentiment-latest"
+```
+
+**3. Cache offline**:
+```bash
+# Baixar modelo manualmente
+from transformers import pipeline
+pipeline("sentiment-analysis", model="nlptown/bert-base-multilingual-uncased-sentiment")
+```
+
+### Modelo carrega muito lentamente
+
+**Sintomas**: Demora excessiva no primeiro carregamento.
+
+**Soluções**:
+
+**1. Habilitar cache**:
+```python
+# Em config.py
+AIConfig.ENABLE_MODEL_CACHE = True
+AIConfig.CACHE_SIZE = 100
+```
+
+**2. Pré-carregar modelos**:
+```python
+# Adicionar ao início do app.py
+from sentiment_analysis import SentimentAnalysisEngine
+engine = SentimentAnalysisEngine()
+engine.model_manager.load_model()  # Pré-carrega
+```
+
+**3. Usar modelo local**:
+```bash
+# Baixar modelo para pasta local
+mkdir models
+# Configurar caminho local em config.py
+```
+
+## 🖥️ Problemas de Interface
+
+### Interface não carrega (erro 500)
+
+**Sintomas**: Página em branco ou erro 500 no navegador.
+
+**Diagnóstico**:
+```bash
+# Verificar logs no terminal
+python -u app.py
+
+# Verificar porta
+netstat -an | findstr 7860
+```
+
+**Soluções**:
+
+**1. Verificar dependências**:
+```python
+try:
+    import gradio as gr
+    print(f"Gradio versão: {gr.__version__}")
+except ImportError as e:
+    print(f"Erro ao importar Gradio: {e}")
+```
+
+**2. Usar porta diferente**:
+```bash
+python app.py --server_port=8080
+```
+
+**3. Modo debug**:
+```python
+# Em app.py
+demo.launch(debug=True, show_error=True)
+```
+
+### Interface trava durante análise
+
+**Sintomas**: Interface não responde após submeter análise.
+
+**Soluções**:
+
+**1. Verificar timeout**:
+```python
+# Em config.py
+AIConfig.MODEL_LOAD_TIMEOUT = 120  # Aumentar timeout
+```
+
+**2. Adicionar indicador de progresso**:
+```python
+# Em ui.py
+def analyze_with_progress(text):
+    yield "🔄 Iniciando análise..."
+    # ... análise
+    yield "✅ Análise concluída!"
+```
+
+**3. Processamento assíncrono**:
+```python
+import asyncio
+
+async def async_analysis(text):
+    # Análise em background
+    pass
+```
+
+### Erro: "Connection refused" ou "Address already in use"
+
+**Sintomas**:
+```
+OSError: [Errno 98] Address already in use
+ConnectionRefusedError: [Errno 111] Connection refused
+```
+
+**Soluções**:
+
+**1. Verificar processos na porta**:
+```bash
+# Windows
+netstat -ano | findstr :7860
+taskkill /PID <PID> /F
+
+# Linux/macOS
+lsof -ti:7860 | xargs kill -9
+```
+
+**2. Usar porta diferente**:
+```bash
+python app.py --server_port=8080
+```
+
+## 📊 Problemas de Performance
+
+### Alto uso de CPU/Memória
+
+**Sintomas**: Sistema lento, ventilador alto.
+
+**Diagnóstico**:
+```python
+# Verificar uso de recursos
+from performance_monitor import PerformanceMonitor
+monitor = PerformanceMonitor()
+monitor.start_monitoring()
+print(monitor.get_current_metrics())
+```
+
+**Soluções**:
+
+**1. Otimizar configurações**:
+```python
+# Em config.py
+AIConfig.MAX_TEXT_LENGTH = 256
+AIConfig.BATCH_SIZE = 2
+AIConfig.USE_GPU = False
+```
+
+**2. Limitar histórico**:
+```python
+# Em performance_monitor.py
+PerformanceMonitor(max_metrics_history=100)
+```
+
+**3. Desabilitar recursos**:
+```python
+# Desabilitar monitoramento em tempo real
+real_time_integration = None
+```
+
+### Análises muito lentas
+
+**Sintomas**: Demora excessiva para gerar resultados.
+
+**Soluções**:
+
+**1. Profile de performance**:
+```python
+import cProfile
+
+def profile_analysis():
+    cProfile.run('engine.analyze_market_data(text)')
+```
+
+**2. Cache de resultados**:
+```python
+from functools import lru_cache
+
+@lru_cache(maxsize=100)
+def cached_analysis(text_hash):
+    return engine.analyze_market_data(text)
+```
+
+**3. Processamento paralelo**:
+```python
+from concurrent.futures import ThreadPoolExecutor
+
+with ThreadPoolExecutor(max_workers=2) as executor:
+    future = executor.submit(analyze_function, text)
+    result = future.result(timeout=30)
+```
+
+## 📁 Problemas de Arquivos e Logs
+
+### Erro: "File not found" para logs
+
+**Sintomas**:
+```
+FileNotFoundError: [Errno 2] No such file or directory: 'trading.log'
+```
+
+**Soluções**:
+
+**1. Verificar caminho**:
+```python
+from pathlib import Path
+log_path = Path("d:/hugging_face_spaces/text")
+print(f"Existe: {log_path.exists()}")
+print(f"É arquivo: {log_path.is_file()}")
+```
+
+**2. Criar arquivo de exemplo**:
+```python
+# Criar log de exemplo para testes
+with open("sample_log.txt", "w") as f:
+    f.write("""⏰ Análise #1 - 09:46:58
+📊 DADOS DE MERCADO - WINV25
+Preço Atual: 140135.00000 ↗
+""")
+```
+
+**3. Configurar caminho correto**:
+```python
+# Em real_time_integration.py
+LOG_FILE_PATH = "caminho/correto/para/logs.txt"
+```
+
+### Erro de permissão em arquivos
+
+**Sintomas**:
+```
+PermissionError: [Errno 13] Permission denied
+```
+
+**Soluções**:
+
+**1. Verificar permissões**:
+```bash
+# Linux/macOS
+ls -la arquivo.log
+chmod 644 arquivo.log
+
+# Windows
+icacls arquivo.log
+```
+
+**2. Executar como administrador**:
+```bash
+# Windows (PowerShell como Admin)
+python app.py
+```
+
+## 🔄 Problemas de Integração em Tempo Real
+
+### FileWatcher não detecta mudanças
+
+**Sintomas**: Logs atualizados mas sistema não processa.
+
+**Diagnóstico**:
+```python
+from real_time_integration import FileWatcher
+
+def test_callback(content):
+    print(f"Arquivo mudou: {len(content)} caracteres")
+
+watcher = FileWatcher("test.txt", test_callback)
+watcher.start()
+```
+
+**Soluções**:
+
+**1. Verificar intervalo**:
+```python
+# Em real_time_integration.py
+config = RealTimeConfig(
+    log_file_path="logs.txt",
+    check_interval=0.5  # Reduzir intervalo
+)
+```
+
+**2. Forçar flush do arquivo**:
+```python
+# No sistema que gera logs
+with open("logs.txt", "a") as f:
+    f.write("nova linha\n")
+    f.flush()  # Forçar escrita
+```
+
+### Eventos duplicados
+
+**Sintomas**: Mesmo evento processado múltiplas vezes.
+
+**Solução**:
+```python
+# Adicionar deduplicação
+class EventDeduplicator:
+    def __init__(self):
+        self.processed_events = set()
+    
+    def is_duplicate(self, event_hash):
+        if event_hash in self.processed_events:
+            return True
+        self.processed_events.add(event_hash)
+        return False
+```
+
+## 🧪 Problemas de Desenvolvimento
+
+### Erro ao importar módulos
+
+**Sintomas**:
+```
+ModuleNotFoundError: No module named 'market_analysis'
+```
+
+**Soluções**:
+
+**1. Verificar PYTHONPATH**:
+```bash
+# Windows
+set PYTHONPATH=%PYTHONPATH%;D:\hugging_face_spaces
+
+# Linux/macOS
+export PYTHONPATH=$PYTHONPATH:/path/to/project
+```
+
+**2. Usar imports relativos**:
+```python
+# Em vez de
+from market_analysis import TechnicalAnalysisEngine
+
+# Use
+from .market_analysis import TechnicalAnalysisEngine
+```
+
+**3. Adicionar ao sys.path**:
+```python
+import sys
+import os
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+```
+
+### Erro de encoding
+
+**Sintomas**:
+```
+UnicodeDecodeError: 'utf-8' codec can't decode
+```
+
+**Soluções**:
+
+**1. Especificar encoding**:
+```python
+with open("arquivo.txt", "r", encoding="utf-8") as f:
+    content = f.read()
+```
+
+**2. Detectar encoding automaticamente**:
+```python
+import chardet
+
+with open("arquivo.txt", "rb") as f:
+    raw_data = f.read()
+    encoding = chardet.detect(raw_data)['encoding']
+    content = raw_data.decode(encoding)
+```
+
+## 🔍 Ferramentas de Diagnóstico
+
+### Script de Diagnóstico Completo
+
+```python
+#!/usr/bin/env python3
+# diagnostic.py
+
+import sys
+import os
+import importlib
+import platform
+import psutil
+from pathlib import Path
+
+def run_diagnostics():
+    print("🔍 DIAGNÓSTICO DO VAMPIRE TRADING BOT")
+    print("=" * 50)
+    
+    # Sistema
+    print(f"🖥️  Sistema: {platform.system()} {platform.release()}")
+    print(f"🐍 Python: {sys.version}")
+    print(f"📁 Diretório: {os.getcwd()}")
+    
+    # Recursos
+    print(f"💾 RAM: {psutil.virtual_memory().total // (1024**3)} GB")
+    print(f"🔥 CPU: {psutil.cpu_count()} cores")
+    
+    # Dependências
+    print("\n📦 DEPENDÊNCIAS:")
+    dependencies = [
+        'gradio', 'transformers', 'torch', 
+        'numpy', 'pandas', 'scipy', 'psutil'
+    ]
+    
+    for dep in dependencies:
+        try:
+            module = importlib.import_module(dep)
+            version = getattr(module, '__version__', 'N/A')
+            print(f"✅ {dep}: {version}")
+        except ImportError:
+            print(f"❌ {dep}: NÃO INSTALADO")
+    
+    # Arquivos
+    print("\n📁 ARQUIVOS:")
+    files = [
+        'app.py', 'config.py', 'market_analysis.py',
+        'sentiment_analysis.py', 'ui.py', 'requirements.txt'
+    ]
+    
+    for file in files:
+        path = Path(file)
+        if path.exists():
+            size = path.stat().st_size
+            print(f"✅ {file}: {size} bytes")
+        else:
+            print(f"❌ {file}: NÃO ENCONTRADO")
+    
+    # Teste de importação
+    print("\n🧪 TESTE DE IMPORTAÇÃO:")
+    modules = [
+        'market_analysis', 'sentiment_analysis', 
+        'fibonacci_analysis', 'ui'
+    ]
+    
+    for module in modules:
+        try:
+            importlib.import_module(module)
+            print(f"✅ {module}: OK")
+        except Exception as e:
+            print(f"❌ {module}: {str(e)[:50]}...")
+    
+    print("\n🏁 Diagnóstico concluído!")
+
+if __name__ == "__main__":
+    run_diagnostics()
+```
+
+### Script de Teste de Performance
+
+```python
+#!/usr/bin/env python3
+# performance_test.py
+
+import time
+import psutil
+from memory_profiler import profile
+
+@profile
+def test_analysis_performance():
+    """Testa performance das análises."""
+    
+    # Simular análise técnica
+    start_time = time.time()
+    
+    # Teste de análise
+    sample_text = "Preço: 140135, Variação: +5, Volume: 5023"
+    
+    try:
+        from market_analysis import TechnicalAnalysisEngine
+        engine = TechnicalAnalysisEngine()
+        result = engine.analyze_market_data(sample_text)
+        
+        end_time = time.time()
+        analysis_time = end_time - start_time
+        
+        print(f"⏱️  Tempo de análise: {analysis_time:.2f}s")
+        print(f"💾 Uso de memória: {psutil.Process().memory_info().rss / 1024 / 1024:.1f} MB")
+        print(f"🔥 Uso de CPU: {psutil.cpu_percent()}%")
+        
+        return True
+        
+    except Exception as e:
+        print(f"❌ Erro na análise: {e}")
+        return False
+
+if __name__ == "__main__":
+    test_analysis_performance()
+```
+
+## 📞 Obtendo Ajuda
+
+### Informações para Suporte
+
+Ao reportar problemas, inclua:
+
+1. **Informações do sistema**:
+   ```bash
+   python diagnostic.py > diagnostic_report.txt
+   ```
+
+2. **Logs de erro completos**:
+   ```bash
+   python app.py > app_log.txt 2>&1
+   ```
+
+3. **Configurações utilizadas**:
+   ```python
+   # Exportar configurações
+   from config import *
+   print(f"Modelo: {FinancialModels.DEFAULT_MODEL}")
+   print(f"RSI: {TechnicalAnalysis.RSI_PERIOD}")
+   ```
+
+### Recursos Adicionais
+
+- 📚 [Documentação da Arquitetura](architecture.md)
+- ⚙️ [Guia de Configuração](configuration.md)
+- 🚀 [Guia de Instalação](installation.md)
+- 📖 [Referência da API](api-reference.md)
+- 👨‍💻 [Guia do Desenvolvedor](developer-guide.md)
+
+### Comunidade e Suporte
+
+- 🐛 **Issues**: Para reportar bugs
+- 💬 **Discussões**: Para dúvidas gerais
+- 📧 **Email**: Para suporte direto
+- 📖 **Wiki**: Para documentação adicional
+
+---
+
+**💡 Dica**: Mantenha sempre uma cópia de backup das suas configurações antes de fazer alterações significativas!

fibonacci_analysis.py

@@ -0,0 +1,528 @@
+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

@@ -0,0 +1,335 @@
+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

@@ -0,0 +1,358 @@
+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()

src/analysis/fibonacci_analysis.py

@@ -0,0 +1,528 @@
+import numpy as np
+import pandas as pd
+from typing import Dict, List, Tuple, Optional, Any
+from dataclasses import dataclass, asdict
+import logging
+from src.core.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))

market_analysis.py → src/analysis/market_analysis.py

@@ -4,13 +4,23 @@ import re
 from typing import Dict, List, Optional, Any
 from dataclasses import dataclass
 from datetime import datetime
+import numpy as np
+import pandas as pd
+import logging
 
-from config import (
+from config.config import (
     TechnicalAnalysisConfig,
     ScoringConfig,
     TradingConfig,
     RegexPatterns
 )
+from ..utils.utils import calculate_rsi, calculate_bollinger_bands, calculate_ema, format_number
+from .fibonacci_analysis import AdvancedFibonacciEngine, AdvancedFibonacciAnalysis
+from ..core.log_parser import VampireBotLogParser, BotAnalysis
+
+# Configurar logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
 
 @dataclass
@@ -332,6 +342,11 @@ class TechnicalAnalysisEngine:
         self.momentum_analyzer = MomentumAnalyzer()
         self.volume_analyzer = VolumeAnalyzer()
         self.setup_detector = ScalpingSetupDetector()
+        self.fibonacci_engine = AdvancedFibonacciEngine()
+        self.log_parser = VampireBotLogParser()
+        self.advanced_processor = AdvancedMarketProcessor()
+        self.config = TECHNICAL_CONFIG
+        logger.info("TechnicalAnalysisEngine inicializado com processamento avançado")
     
     def analyze(self, market_data: MarketData) -> Dict[str, Any]:
         """Executa análise técnica completa."""
@@ -348,14 +363,22 @@ class TechnicalAnalysisEngine:
         special_signals = self.setup_detector.detect_perfect_setups(market_data, signals)
         all_signals = signals + special_signals
         
+        # Análise avançada de Fibonacci
+        fibonacci_analysis = self._perform_fibonacci_analysis(market_data)
+        
+        # Processamento avançado de mercado
+        advanced_analysis = self._perform_advanced_market_analysis(market_data)
+        
         # Calcular ação e confiança
         action, confidence = self._calculate_action_and_confidence(all_signals)
         
         return {
             'action': action,
             'confidence': confidence,
-            'signals': all_signals,
-            'market_data': market_data
+             'signals': all_signals,
+             'fibonacci': fibonacci_analysis,
+             'advanced_analysis': advanced_analysis,
+             'market_data': market_data
         }
     
     def _calculate_action_and_confidence(self, signals: List[TechnicalSignal]) -> tuple[str, int]:
@@ -390,6 +413,124 @@ class TechnicalAnalysisEngine:
                              min(ScoringConfig.MAX_CONFIDENCE, confidence_score))
         
         return action, confidence_score
+    
+    def _perform_fibonacci_analysis(self, market_data: MarketData) -> Dict[str, Any]:
+        """Executa análise avançada de Fibonacci."""
+        try:
+            # Simular dados de preço para análise Fibonacci
+            prices = np.array([market_data.price * (1 + np.random.normal(0, 0.01)) for _ in range(100)])
+            
+            # Executar análise Fibonacci
+            fib_analysis = self.fibonacci_engine.analyze_fibonacci_levels(
+                prices=prices,
+                current_price=market_data.price
+            )
+            
+            return {
+                'levels': fib_analysis.levels if fib_analysis else {},
+                'signals': fib_analysis.signals if fib_analysis else [],
+                'confluence_zones': fib_analysis.confluence_zones if fib_analysis else [],
+                'strength': fib_analysis.overall_strength if fib_analysis else 0
+            }
+        except Exception as e:
+            logger.error(f"Erro na análise Fibonacci: {e}")
+            return {
+                'levels': {},
+                'signals': [],
+                'confluence_zones': [],
+                'strength': 0
+            }
+    
+    def process_bot_log_data(self, log_content: str) -> Dict[str, Any]:
+        """Processa dados de log do bot externo."""
+        try:
+            # Parse do log
+            bot_analysis = self.log_parser.parse_log(log_content)
+            
+            if not bot_analysis:
+                return {'error': 'Falha ao processar log do bot'}
+            
+            # Converter para MarketData
+            market_data = MarketData(
+                price=bot_analysis.market_info.price,
+                variation=0,  # Será calculado se necessário
+                rsi=bot_analysis.technical_indicators.rsi if bot_analysis.technical_indicators else 50,
+                ema_trend=bot_analysis.technical_indicators.ema if bot_analysis.technical_indicators else 'NEUTRO',
+                bb_position=bot_analysis.technical_indicators.bollinger if bot_analysis.technical_indicators else 'DENTRO',
+                volume=bot_analysis.market_info.volume
+            )
+            
+            # Executar análise completa
+            analysis_result = self.analyze(market_data)
+            
+            # Adicionar dados específicos do bot
+            analysis_result['bot_data'] = {
+                'fibonacci_alerts': bot_analysis.fibonacci_analysis.alerts if bot_analysis.fibonacci_analysis else 0,
+                'fibonacci_signal': bot_analysis.fibonacci_analysis.signal if bot_analysis.fibonacci_analysis else 'UNKNOWN',
+                'technical_indicators': {
+                    'rsi': bot_analysis.technical_indicators.rsi if bot_analysis.technical_indicators else None,
+                    'ema': bot_analysis.technical_indicators.ema if bot_analysis.technical_indicators else None,
+                    'bollinger': bot_analysis.technical_indicators.bollinger if bot_analysis.technical_indicators else None,
+                    'atr': bot_analysis.technical_indicators.atr if bot_analysis.technical_indicators else None
+                },
+                'original_analysis': bot_analysis
+            }
+            
+            return analysis_result
+            
+        except Exception as e:
+             logger.error(f"Erro ao processar dados do bot: {e}")
+             return {'error': f'Erro no processamento: {str(e)}'}
+    
+    def _perform_advanced_market_analysis(self, market_data: MarketData) -> Dict[str, Any]:
+        """Executa análise avançada de mercado com swing points e padrões harmônicos."""
+        try:
+            # Simular dados históricos de preço para análise
+            base_price = market_data.price
+            prices = np.array([base_price * (1 + np.random.normal(0, 0.02)) for _ in range(100)])
+            volumes = np.array([1000 + np.random.randint(-200, 200) for _ in range(100)])
+            
+            # Níveis de Fibonacci simulados
+            fibonacci_levels = {
+                '23.6%': base_price * 0.764,
+                '38.2%': base_price * 0.618,
+                '50.0%': base_price * 0.5,
+                '61.8%': base_price * 0.382,
+                '78.6%': base_price * 0.214
+            }
+            
+            # Níveis de suporte/resistência simulados
+            support_resistance = [
+                base_price * 0.95,
+                base_price * 0.98,
+                base_price * 1.02,
+                base_price * 1.05
+            ]
+            
+            # Executar processamento avançado
+            advanced_result = self.advanced_processor.process_market_data(
+                prices=prices,
+                volumes=volumes,
+                fibonacci_levels=fibonacci_levels,
+                support_resistance_levels=support_resistance
+            )
+            
+            return advanced_result
+            
+        except Exception as e:
+            logger.error(f"Erro na análise avançada de mercado: {e}")
+            return {
+                'swing_points': {'count': 0, 'highs': [], 'lows': [], 'avg_strength': 0},
+                'confluence_zones': {'count': 0, 'zones': [], 'strongest_zone': None},
+                'harmonic_patterns': {'count': 0, 'patterns': [], 'most_reliable': None},
+                'market_structure': 'UNKNOWN',
+                'key_levels': []
+            }
+
+
+class MarketAnalyzer:
+    """Analisador principal de mercado."""
+    pass
 
 
 class RiskCalculator:

src/analysis/sentiment_analysis.py

@@ -0,0 +1,331 @@
+"""Módulo de análise de sentimento usando IA financeira."""
+
+import re
+from typing import Dict, Optional, Any
+from dataclasses import dataclass
+
+from config.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/core/log_parser.py

@@ -0,0 +1,335 @@
+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")

src/core/performance_monitor.py

@@ -0,0 +1,366 @@
+import time
+import psutil
+import threading
+from datetime import datetime, timedelta
+from typing import Dict, List, Any, Optional
+from dataclasses import dataclass, asdict
+from collections import deque, defaultdict
+import json
+import logging
+from pathlib import Path
+
+@dataclass
+class PerformanceMetrics:
+    """Métricas de performance do sistema"""
+    timestamp: datetime
+    cpu_usage: float
+    memory_usage: float
+    memory_available: float
+    disk_usage: float
+    analysis_time: float = 0.0
+    events_processed: int = 0
+    errors_count: int = 0
+    bot_signals_count: int = 0
+    fibonacci_alerts_count: int = 0
+
+@dataclass
+class BotPerformanceStats:
+    """Estatísticas de performance específicas do bot"""
+    total_analyses: int = 0
+    successful_analyses: int = 0
+    failed_analyses: int = 0
+    average_analysis_time: float = 0.0
+    signals_generated: Dict[str, int] = None
+    fibonacci_accuracy: float = 0.0
+    last_update: datetime = None
+    
+    def __post_init__(self):
+        if self.signals_generated is None:
+            self.signals_generated = {'COMPRAR': 0, 'VENDER': 0, 'AGUARDAR': 0}
+        if self.last_update is None:
+            self.last_update = datetime.now()
+
+class PerformanceMonitor:
+    """Monitor de performance do sistema e bot"""
+    
+    def __init__(self, max_metrics_history: int = 1000):
+        self.max_metrics_history = max_metrics_history
+        self.metrics_history = deque(maxlen=max_metrics_history)
+        self.bot_stats = BotPerformanceStats()
+        self.analysis_times = deque(maxlen=100)  # Últimos 100 tempos de análise
+        self.error_log = deque(maxlen=50)  # Últimos 50 erros
+        
+        self.monitoring = False
+        self.monitor_thread = None
+        self.lock = threading.Lock()
+        
+        # Setup logging
+        self.logger = logging.getLogger(__name__)
+        
+        # Alertas de performance
+        self.performance_alerts = {
+            'high_cpu': {'threshold': 80.0, 'triggered': False},
+            'high_memory': {'threshold': 85.0, 'triggered': False},
+            'slow_analysis': {'threshold': 5.0, 'triggered': False},  # segundos
+            'high_error_rate': {'threshold': 0.1, 'triggered': False}  # 10%
+        }
+        
+    def start_monitoring(self, interval: float = 5.0):
+        """Inicia o monitoramento de performance"""
+        if self.monitoring:
+            return
+            
+        self.monitoring = True
+        self.monitor_thread = threading.Thread(
+            target=self._monitoring_loop,
+            args=(interval,),
+            daemon=True
+        )
+        self.monitor_thread.start()
+        self.logger.info(f"Monitoramento de performance iniciado (intervalo: {interval}s)")
+        
+    def stop_monitoring(self):
+        """Para o monitoramento de performance"""
+        self.monitoring = False
+        if self.monitor_thread:
+            self.monitor_thread.join(timeout=1.0)
+        self.logger.info("Monitoramento de performance parado")
+        
+    def _monitoring_loop(self, interval: float):
+        """Loop principal de monitoramento"""
+        while self.monitoring:
+            try:
+                metrics = self._collect_system_metrics()
+                
+                with self.lock:
+                    self.metrics_history.append(metrics)
+                    
+                # Verificar alertas
+                self._check_performance_alerts(metrics)
+                
+                time.sleep(interval)
+                
+            except Exception as e:
+                self.logger.error(f"Erro no monitoramento: {e}")
+                time.sleep(interval)
+                
+    def _collect_system_metrics(self) -> PerformanceMetrics:
+        """Coleta métricas do sistema"""
+        # CPU
+        cpu_usage = psutil.cpu_percent(interval=0.1)
+        
+        # Memória
+        memory = psutil.virtual_memory()
+        memory_usage = memory.percent
+        memory_available = memory.available / (1024**3)  # GB
+        
+        # Disco
+        disk = psutil.disk_usage('/')
+        disk_usage = disk.percent
+        
+        return PerformanceMetrics(
+            timestamp=datetime.now(),
+            cpu_usage=cpu_usage,
+            memory_usage=memory_usage,
+            memory_available=memory_available,
+            disk_usage=disk_usage
+        )
+        
+    def record_analysis_time(self, analysis_time: float):
+        """Registra tempo de análise"""
+        with self.lock:
+            self.analysis_times.append(analysis_time)
+            self.bot_stats.total_analyses += 1
+            
+            # Atualizar tempo médio
+            if self.analysis_times:
+                self.bot_stats.average_analysis_time = sum(self.analysis_times) / len(self.analysis_times)
+                
+    def record_successful_analysis(self, signal: str = None):
+        """Registra análise bem-sucedida"""
+        with self.lock:
+            self.bot_stats.successful_analyses += 1
+            
+            if signal and signal in self.bot_stats.signals_generated:
+                self.bot_stats.signals_generated[signal] += 1
+                
+            self.bot_stats.last_update = datetime.now()
+            
+    def record_failed_analysis(self, error: str):
+        """Registra análise falhada"""
+        with self.lock:
+            self.bot_stats.failed_analyses += 1
+            self.error_log.append({
+                'timestamp': datetime.now(),
+                'error': error
+            })
+            self.bot_stats.last_update = datetime.now()
+            
+    def record_fibonacci_alert(self):
+        """Registra alerta de Fibonacci"""
+        with self.lock:
+            self.bot_stats.fibonacci_alerts_count += 1
+            
+    def _check_performance_alerts(self, metrics: PerformanceMetrics):
+        """Verifica alertas de performance"""
+        # CPU alto
+        if metrics.cpu_usage > self.performance_alerts['high_cpu']['threshold']:
+            if not self.performance_alerts['high_cpu']['triggered']:
+                self.logger.warning(f"ALERTA: CPU alto ({metrics.cpu_usage:.1f}%)")
+                self.performance_alerts['high_cpu']['triggered'] = True
+        else:
+            self.performance_alerts['high_cpu']['triggered'] = False
+            
+        # Memória alta
+        if metrics.memory_usage > self.performance_alerts['high_memory']['threshold']:
+            if not self.performance_alerts['high_memory']['triggered']:
+                self.logger.warning(f"ALERTA: Memória alta ({metrics.memory_usage:.1f}%)")
+                self.performance_alerts['high_memory']['triggered'] = True
+        else:
+            self.performance_alerts['high_memory']['triggered'] = False
+            
+        # Análise lenta
+        if self.analysis_times and self.bot_stats.average_analysis_time > self.performance_alerts['slow_analysis']['threshold']:
+            if not self.performance_alerts['slow_analysis']['triggered']:
+                self.logger.warning(f"ALERTA: Análise lenta ({self.bot_stats.average_analysis_time:.2f}s)")
+                self.performance_alerts['slow_analysis']['triggered'] = True
+        else:
+            self.performance_alerts['slow_analysis']['triggered'] = False
+            
+        # Taxa de erro alta
+        if self.bot_stats.total_analyses > 0:
+            error_rate = self.bot_stats.failed_analyses / self.bot_stats.total_analyses
+            if error_rate > self.performance_alerts['high_error_rate']['threshold']:
+                if not self.performance_alerts['high_error_rate']['triggered']:
+                    self.logger.warning(f"ALERTA: Taxa de erro alta ({error_rate:.1%})")
+                    self.performance_alerts['high_error_rate']['triggered'] = True
+            else:
+                self.performance_alerts['high_error_rate']['triggered'] = False
+                
+    def get_current_metrics(self) -> Optional[PerformanceMetrics]:
+        """Retorna métricas atuais"""
+        with self.lock:
+            return self.metrics_history[-1] if self.metrics_history else None
+            
+    def get_metrics_history(self, minutes: int = 60) -> List[PerformanceMetrics]:
+        """Retorna histórico de métricas dos últimos N minutos"""
+        cutoff_time = datetime.now() - timedelta(minutes=minutes)
+        
+        with self.lock:
+            return [m for m in self.metrics_history if m.timestamp >= cutoff_time]
+            
+    def get_bot_stats(self) -> BotPerformanceStats:
+        """Retorna estatísticas do bot"""
+        with self.lock:
+            return BotPerformanceStats(
+                total_analyses=self.bot_stats.total_analyses,
+                successful_analyses=self.bot_stats.successful_analyses,
+                failed_analyses=self.bot_stats.failed_analyses,
+                average_analysis_time=self.bot_stats.average_analysis_time,
+                signals_generated=self.bot_stats.signals_generated.copy(),
+                fibonacci_accuracy=self.bot_stats.fibonacci_accuracy,
+                last_update=self.bot_stats.last_update
+            )
+            
+    def get_performance_summary(self) -> Dict[str, Any]:
+        """Retorna resumo de performance"""
+        current_metrics = self.get_current_metrics()
+        bot_stats = self.get_bot_stats()
+        
+        # Calcular estatísticas dos últimos 30 minutos
+        recent_metrics = self.get_metrics_history(30)
+        
+        avg_cpu = sum(m.cpu_usage for m in recent_metrics) / len(recent_metrics) if recent_metrics else 0
+        avg_memory = sum(m.memory_usage for m in recent_metrics) / len(recent_metrics) if recent_metrics else 0
+        
+        # Taxa de sucesso
+        success_rate = 0
+        if bot_stats.total_analyses > 0:
+            success_rate = bot_stats.successful_analyses / bot_stats.total_analyses
+            
+        # Alertas ativos
+        active_alerts = [name for name, alert in self.performance_alerts.items() if alert['triggered']]
+        
+        return {
+            'current_metrics': asdict(current_metrics) if current_metrics else None,
+            'bot_stats': asdict(bot_stats),
+            'averages_30min': {
+                'cpu_usage': avg_cpu,
+                'memory_usage': avg_memory
+            },
+            'success_rate': success_rate,
+            'active_alerts': active_alerts,
+            'recent_errors': list(self.error_log)[-5:],  # Últimos 5 erros
+            'monitoring_status': self.monitoring
+        }
+        
+    def export_metrics(self, filepath: str, hours: int = 24):
+        """Exporta métricas para arquivo JSON"""
+        metrics_data = self.get_metrics_history(hours * 60)
+        bot_stats = self.get_bot_stats()
+        
+        export_data = {
+            'export_timestamp': datetime.now().isoformat(),
+            'metrics_history': [asdict(m) for m in metrics_data],
+            'bot_statistics': asdict(bot_stats),
+            'performance_summary': self.get_performance_summary()
+        }
+        
+        # Converter datetime para string
+        def datetime_converter(obj):
+            if isinstance(obj, datetime):
+                return obj.isoformat()
+            raise TypeError(f"Object of type {type(obj)} is not JSON serializable")
+            
+        with open(filepath, 'w', encoding='utf-8') as f:
+            json.dump(export_data, f, indent=2, default=datetime_converter, ensure_ascii=False)
+            
+        self.logger.info(f"Métricas exportadas para: {filepath}")
+        
+    def reset_stats(self):
+        """Reseta estatísticas do bot"""
+        with self.lock:
+            self.bot_stats = BotPerformanceStats()
+            self.analysis_times.clear()
+            self.error_log.clear()
+            
+        self.logger.info("Estatísticas resetadas")
+        
+    def optimize_performance(self) -> List[str]:
+        """Sugere otimizações baseadas nas métricas"""
+        suggestions = []
+        current_metrics = self.get_current_metrics()
+        bot_stats = self.get_bot_stats()
+        
+        if current_metrics:
+            # CPU alto
+            if current_metrics.cpu_usage > 70:
+                suggestions.append("CPU alto detectado. Considere reduzir a frequência de análise.")
+                
+            # Memória alta
+            if current_metrics.memory_usage > 80:
+                suggestions.append("Uso de memória alto. Considere limpar cache ou reduzir histórico.")
+                
+            # Análise lenta
+            if bot_stats.average_analysis_time > 3.0:
+                suggestions.append("Análises lentas detectadas. Verifique a complexidade dos cálculos.")
+                
+            # Taxa de erro alta
+            if bot_stats.total_analyses > 10:
+                error_rate = bot_stats.failed_analyses / bot_stats.total_analyses
+                if error_rate > 0.05:  # 5%
+                    suggestions.append(f"Taxa de erro alta ({error_rate:.1%}). Verifique logs de erro.")
+                    
+        if not suggestions:
+            suggestions.append("Sistema operando dentro dos parâmetros normais.")
+            
+        return suggestions
+
+# Instância global do monitor
+performance_monitor = PerformanceMonitor()
+
+# Decorador para medir tempo de análise
+def measure_analysis_time(func):
+    """Decorador para medir tempo de análise"""
+    def wrapper(*args, **kwargs):
+        start_time = time.time()
+        try:
+            result = func(*args, **kwargs)
+            analysis_time = time.time() - start_time
+            performance_monitor.record_analysis_time(analysis_time)
+            performance_monitor.record_successful_analysis()
+            return result
+        except Exception as e:
+            analysis_time = time.time() - start_time
+            performance_monitor.record_analysis_time(analysis_time)
+            performance_monitor.record_failed_analysis(str(e))
+            raise
+    return wrapper
+
+# Exemplo de uso
+if __name__ == "__main__":
+    # Configurar logging
+    logging.basicConfig(level=logging.INFO)
+    
+    # Iniciar monitoramento
+    monitor = PerformanceMonitor()
+    monitor.start_monitoring(interval=2.0)
+    
+    try:
+        # Simular algumas análises
+        for i in range(10):
+            time.sleep(1)
+            monitor.record_analysis_time(0.5 + i * 0.1)
+            if i % 3 == 0:
+                monitor.record_successful_analysis('COMPRAR')
+            else:
+                monitor.record_successful_analysis('AGUARDAR')
+                
+        # Mostrar resumo
+        summary = monitor.get_performance_summary()
+        print(json.dumps(summary, indent=2, default=str))
+        
+    except KeyboardInterrupt:
+        print("Parando monitor...")
+    finally:
+        monitor.stop_monitoring()

src/integrations/real_time_integration.py

@@ -0,0 +1,358 @@
+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 src.core.log_parser import VampireBotLogParser, BotAnalysis
+from src.analysis.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()

src/ui/gradio_interface.py

@@ -0,0 +1,828 @@
+"""Módulo de interface do usuário com Gradio."""
+
+import gradio as gr
+from typing import Dict, Any, Optional, Tuple
+
+from config.config import UIConfig, AppConfig
+from src.utils.utils import (
+    DateTimeUtils,
+    NumberUtils,
+    ConfidenceUtils,
+    ActionUtils,
+    SentimentUtils,
+    FormatUtils
+)
+
+
+class UIComponents:
+    """Componentes da interface do usuário."""
+    
+    @staticmethod
+    def create_header() -> str:
+        """Cria o 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 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)

src/utils/utils.py

@@ -0,0 +1,330 @@
+"""Módulo de utilitários e funções auxiliares."""
+
+import json
+from datetime import datetime
+from typing import Dict, Any, Optional
+
+from config.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)
+        }

text

@@ -0,0 +1,76 @@
+⏰ 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)
+2025-08-27 09:46:58,218 - src.core.analysis.advanced_fibonacci - INFO - 🔮 INICIANDO ANÁLISE AVANÇADA DE FIBONACCI - Lookback: 40 períodos
+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
+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,339 - src.core.analysis.advanced_fibonacci - INFO - 🔮 INICIANDO ANÁLISE AVANÇADA DE FIBONACCI - Lookback: 40 períodos
+2025-08-27 09:46:58,340 - 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,340 - src.core.analysis.advanced_fibonacci - INFO - 📏 Diferença Swing: 1,030.00 pontos
+2025-08-27 09:46:58,365 - src.core.analysis.advanced_fibonacci - INFO - 📈 Níveis de Retracement calculados: 13 níveis
+2025-08-27 09:46:58,396 - src.core.analysis.advanced_fibonacci - INFO - 📊 Níveis de Extensão calculados: 11 níveis
+2025-08-27 09:46:58,418 - src.core.analysis.advanced_fibonacci - INFO - 🎯 Níveis de Projeção calculados: 8 níveis
+2025-08-27 09:46:58,419 - src.core.analysis.advanced_fibonacci - INFO - 🔢 Total de níveis Fibonacci: 32
+2025-08-27 09:46:58,421 - src.core.analysis.advanced_fibonacci - INFO - 🎯 Zonas de Confluência detectadas: 0
+2025-08-27 09:46:58,423 - src.core.analysis.advanced_fibonacci - INFO - 🎼 Padrões Harmônicos detectados: 0
+2025-08-27 09:46:58,424 - src.core.analysis.advanced_fibonacci - INFO - ⏰ Projeções Temporais calculadas: 0
+2025-08-27 09:46:58,425 - src.core.analysis.advanced_fibonacci - INFO - 💪 Força Geral da Análise: 0.00
+2025-08-27 09:46:58,427 - 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,428 - src.core.analysis.advanced_fibonacci - INFO - 🔮 INICIANDO ANÁLISE AVANÇADA DE FIBONACCI - Lookback: 40 períodos
+2025-08-27 09:46:58,430 - 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,431 - src.core.analysis.advanced_fibonacci - INFO - 📏 Diferença Swing: 1,030.00 pontos
+2025-08-27 09:46:58,460 - src.core.analysis.advanced_fibonacci - INFO - 📈 Níveis de Retracement calculados: 13 níveis
+2025-08-27 09:46:58,487 - src.core.analysis.advanced_fibonacci - INFO - 📊 Níveis de Extensão calculados: 11 níveis
+2025-08-27 09:46:58,504 - src.core.analysis.advanced_fibonacci - INFO - 🎯 Níveis de Projeção calculados: 8 níveis
+2025-08-27 09:46:58,520 - src.core.analysis.advanced_fibonacci - INFO - 🔢 Total de níveis Fibonacci: 32
+2025-08-27 09:46:58,543 - src.core.analysis.advanced_fibonacci - INFO - 🎯 Zonas de Confluência detectadas: 0
+2025-08-27 09:46:58,558 - src.core.analysis.advanced_fibonacci - INFO - 🎼 Padrões Harmônicos detectados: 0
+2025-08-27 09:46:58,575 - src.core.analysis.advanced_fibonacci - INFO - ⏰ Projeções Temporais calculadas: 0
+2025-08-27 09:46:58,606 - src.core.analysis.advanced_fibonacci - INFO - 💪 Força Geral da Análise: 0.00
+2025-08-27 09:46:58,614 - 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,618 - src.core.analysis.advanced_fibonacci - INFO - 🔮 INICIANDO ANÁLISE AVANÇADA DE FIBONACCI - Lookback: 40 períodos
+2025-08-27 09:46:58,622 - 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,624 - src.core.analysis.advanced_fibonacci - INFO - 📏 Diferença Swing: 1,030.00 pontos
+2025-08-27 09:46:58,696 - src.core.analysis.advanced_fibonacci - INFO - 📈 Níveis de Retracement calculados: 13 níveis
+2025-08-27 09:46:58,758 - src.core.analysis.advanced_fibonacci - INFO - 📊 Níveis de Extensão calculados: 11 níveis
+2025-08-27 09:46:58,808 - src.core.analysis.advanced_fibonacci - INFO - 🎯 Níveis de Projeção calculados: 8 níveis
+2025-08-27 09:46:58,821 - src.core.analysis.advanced_fibonacci - INFO - 🔢 Total de níveis Fibonacci: 32
+2025-08-27 09:46:58,832 - src.core.analysis.advanced_fibonacci - INFO - 🎯 Zonas de Confluência detectadas: 0
+2025-08-27 09:46:58,840 - src.core.analysis.advanced_fibonacci - INFO - 🎼 Padrões Harmônicos detectados: 0
+2025-08-27 09:46:58,841 - src.core.analysis.advanced_fibonacci - INFO - ⏰ Projeções Temporais calculadas: 0
+2025-08-27 09:46:58,850 - src.core.analysis.advanced_fibonacci - INFO - 💪 Força Geral da Análise: 0.00
+2025-08-27 09:46:58,855 - 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,859 - src.core.managers.performance_optimizer - WARNING - Análise de mercado lenta: 0.526s
+2025-08-27 09:46:58,869 - __main__ - INFO - 📊 FIBONACCI AVANÇADO ENVIADO:  Alertas:15 FibSinal:HOLD
+🔮 Fibonacci Avançado:  Alertas:15 FibSinal:HOLD

ui.py

@@ -17,6 +17,194 @@ from utils import (
 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."""
@@ -44,20 +232,47 @@ class UIComponents:
             </div>
             """)
             
-            market_input = gr.Textbox(
-                label="Dados do Mercado",
-                placeholder=AppConfig.EXAMPLE_INPUT,
-                lines=8,
-                max_lines=15
-            )
-            
-            analyze_btn = gr.Button(
-                "🔍 Analisar Mercado",
-                variant="primary",
-                size="lg"
-            )
+            # 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
+        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]]:
@@ -87,11 +302,25 @@ class UIComponents:
                 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()
         
-        return output_section, outputs
+        # 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:
@@ -329,6 +558,61 @@ class GradioInterface:
         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(
@@ -343,7 +627,7 @@ class GradioInterface:
             with gr.Row():
                 # Coluna de entrada (40%)
                 with gr.Column(scale=2):
-                    input_section, market_input, analyze_btn = UIComponents.create_input_section()
+                    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):
@@ -352,7 +636,7 @@ class GradioInterface:
             # Rodapé
             gr.HTML(UIComponents.create_footer(self.model_info))
             
-            # Configurar evento de análise
+            # Configurar eventos de análise
             analyze_btn.click(
                 fn=self._analyze_wrapper,
                 inputs=[market_input],
@@ -362,6 +646,23 @@ class GradioInterface:
                     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']
                 ]
             )
@@ -378,7 +679,7 @@ class GradioInterface:
         self.interface = interface
         return interface
     
-    def _analyze_wrapper(self, market_input: str) -> Tuple[str, str, str, str, str, Dict[str, Any]]:
+    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
@@ -394,6 +695,8 @@ class GradioInterface:
             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 = {
@@ -407,6 +710,8 @@ class GradioInterface:
                 technical_analysis,
                 sentiment_analysis,
                 recommendations,
+                harmonic_patterns,
+                fibonacci_alerts,
                 raw_data
             )
             
@@ -425,6 +730,43 @@ class GradioInterface:
                 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}
             )