teste / src /core /log_parser.py
torxyton's picture
Initial commit: Complete Fibonacci analysis application with Gradio interface
7f335a2
Raw History Blame Contribute Delete
15.7 kB
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")