analyze_collected_data.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Analisador de Dados Coletados - profit_dll_monitor.py
Script para analisar os dados coletados e preparar para ML
"""

import pandas as pd
import json
import numpy as np
from pathlib import Path
import matplotlib.pyplot as plt
import seaborn as sns
from datetime import datetime
import warnings
warnings.filterwarnings('ignore')

class DataAnalyzer:
    """Analisador de dados coletados do monitor de trading"""
    
    def __init__(self, data_dir="./data"):
        """
        Inicializa o analisador
        
        Args:
            data_dir: Diretório com os dados coletados
        """
        self.data_dir = Path(data_dir)
        self.sessions = self._discover_sessions()
        
    def _discover_sessions(self):
        """Descobre todas as sessões disponíveis"""
        sessions = {}
        
        # Procurar por arquivos de trades
        trades_dir = self.data_dir / "trades"
        if trades_dir.exists():
            for file in trades_dir.glob("trades_*.csv"):
                session_id = file.stem.replace("trades_", "")
                if session_id not in sessions:
                    sessions[session_id] = {}
                sessions[session_id]['trades'] = file
        
        # Procurar por outros arquivos
        for subdir in ['regimes', 'temperature', 'snapshots', 'features']:
            dir_path = self.data_dir / subdir
            if dir_path.exists():
                for file in dir_path.glob(f"{subdir}_*.json"):
                    session_id = file.stem.replace(f"{subdir}_", "")
                    if session_id not in sessions:
                        sessions[session_id] = {}
                    sessions[session_id][subdir] = file
        
        return sessions
    
    def list_sessions(self):
        """Lista todas as sessões disponíveis"""
        print(f"SESSOES DISPONIVEIS ({len(self.sessions)}):")
        print(f"{'='*60}")
        
        for session_id, files in self.sessions.items():
            # Converter session_id para datetime para exibição
            try:
                dt = datetime.strptime(session_id, "%Y%m%d_%H%M%S")
                dt_str = dt.strftime("%d/%m/%Y %H:%M:%S")
            except:
                dt_str = session_id
            
            print(f"🗓️  {dt_str}")
            print(f"   ID: {session_id}")
            print(f"   Arquivos: {', '.join(files.keys())}")
            
            # Estatísticas rápidas se tiver trades
            if 'trades' in files:
                try:
                    df_trades = pd.read_csv(files['trades'])
                    print(f"   📈 Trades: {len(df_trades):,} | "
                          f"Volume: R$ {df_trades['volume'].sum():,.0f}")
                except:
                    print("   📈 Trades: Erro ao ler")
            print()
    
    def load_session_data(self, session_id):
        """
        Carrega todos os dados de uma sessão
        
        Args:
            session_id: ID da sessão
            
        Returns:
            Dict com todos os dados da sessão
        """
        if session_id not in self.sessions:
            raise ValueError(f"Sessão {session_id} não encontrada")
        
        session_data = {}
        files = self.sessions[session_id]
        
        # Carregar trades (CSV)
        if 'trades' in files:
            session_data['trades'] = pd.read_csv(files['trades'])
            session_data['trades']['timestamp'] = pd.to_datetime(session_data['trades']['timestamp'], format='mixed')
        
        # Carregar dados JSON
        for data_type in ['regimes', 'temperature', 'snapshots', 'features']:
            if data_type in files:
                with open(files[data_type], 'r', encoding='utf-8') as f:
                    session_data[data_type] = json.load(f)
        
        return session_data
    
    def analyze_session(self, session_id):
        """
        Análise completa de uma sessão
        
        Args:
            session_id: ID da sessão
        """
        print(f"🔍 ANALISANDO SESSÃO: {session_id}")
        print(f"{'='*80}")
        
        data = self.load_session_data(session_id)
        
        # 1. Análise de Trades
        if 'trades' in data:
            self._analyze_trades(data['trades'])
        
        # 2. Análise de Temperatura
        if 'temperature' in data:
            self._analyze_temperature(data['temperature'])
        
        # 3. Análise de Regimes
        if 'regimes' in data:
            self._analyze_regimes(data['regimes'])
        
        # 4. Análise de Snapshots
        if 'snapshots' in data:
            self._analyze_snapshots(data['snapshots'])
    
    def _analyze_trades(self, df_trades):
        """Análise detalhada dos trades"""
        print(f"\n📈 ANÁLISE DE TRADES:")
        print(f"-" * 40)
        
        # Estatísticas básicas
        print(f"Total de trades: {len(df_trades):,}")
        print(f"Volume total: R$ {df_trades['volume'].sum():,.2f}")
        print(f"Quantidade total: {df_trades['quantity'].sum():,} contratos")
        print(f"Preço médio: R$ {df_trades['price'].mean():.3f}")
        print(f"Faixa de preços: R$ {df_trades['price'].min():.3f} - R$ {df_trades['price'].max():.3f}")
        
        # Análise por categoria
        print(f"\nPor categoria de corretora:")
        for categoria in ['institucional', 'varejo', 'outros']:
            mask = (df_trades['buy_categoria'] == categoria) | (df_trades['sell_categoria'] == categoria)
            cat_trades = df_trades[mask]
            if len(cat_trades) > 0:
                volume_cat = cat_trades['volume'].sum()
                print(f"   {categoria.title()}: {len(cat_trades):,} trades | R$ {volume_cat:,.0f}")
        
        # Top corretoras
        print(f"\n🏆 Top 10 corretoras por volume:")
        
        # Consolidar dados por corretora
        corretora_stats = {}
        for _, row in df_trades.iterrows():
            for agent_col, nome_col in [('buy_agent', 'buy_nome'), ('sell_agent', 'sell_nome')]:
                agent_id = row[agent_col]
                nome = row[nome_col]
                
                if agent_id not in corretora_stats:
                    corretora_stats[agent_id] = {'nome': nome, 'volume': 0, 'trades': 0}
                
                corretora_stats[agent_id]['volume'] += row['volume'] / 2  # Dividir por 2 pois cada trade conta 2x
                corretora_stats[agent_id]['trades'] += 0.5  # Dividir por 2 pois cada trade conta 2x
        
        # Ordenar e exibir top 10
        top_corretoras = sorted(corretora_stats.items(), 
                               key=lambda x: x[1]['volume'], reverse=True)[:10]
        
        for i, (agent_id, stats) in enumerate(top_corretoras, 1):
            print(f"   {i:2d}. {stats['nome']} - R$ {stats['volume']:>12,.0f} "
                  f"({int(stats['trades']):,} trades)")
    
    def _analyze_temperature(self, temp_data):
        """Análise da temperatura do mercado"""
        print(f"\n🌡️  ANÁLISE DE TEMPERATURA:")
        print(f"-" * 40)
        
        if not temp_data:
            print("Nenhum dado de temperatura disponível")
            return
        
        temperatures = [t['temperatura_geral']['temperatura'] for t in temp_data]
        
        print(f"Registros de temperatura: {len(temperatures)}")
        print(f"Temperatura média: {np.mean(temperatures):.1f}°")
        print(f"Temperatura máxima: {max(temperatures):.1f}°")
        print(f"Temperatura mínima: {min(temperatures):.1f}°")
        print(f"Desvio padrão: {np.std(temperatures):.1f}°")
        
        # Distribuição por classificação
        classificacoes = [t['temperatura_geral']['classificacao'] for t in temp_data]
        from collections import Counter
        dist_class = Counter(classificacoes)
        
        print(f"\nDistribuição por classificação:")
        for classe, count in dist_class.items():
            pct = (count / len(classificacoes)) * 100
            print(f"   {classe.title()}: {count} ({pct:.1f}%)")
    
    def _analyze_regimes(self, regime_data):
        """Análise dos regimes de mercado"""
        print(f"\n📈 ANÁLISE DE REGIMES:")
        print(f"-" * 40)
        
        if not regime_data:
            print("Nenhum dado de regime disponível")
            return
        
        regimes = [r['regime'] for r in regime_data]
        confiancas = [r['confianca'] for r in regime_data]
        
        print(f"Registros de regime: {len(regimes)}")
        print(f"Confiança média: {np.mean(confiancas):.1f}%")
        
        # Distribuição de regimes
        from collections import Counter
        dist_regimes = Counter(regimes)
        
        print(f"\nDistribuição de regimes:")
        for regime, count in dist_regimes.items():
            pct = (count / len(regimes)) * 100
            print(f"   {regime}: {count} ({pct:.1f}%)")
        
        # Mudanças de regime
        mudancas = 0
        for i in range(1, len(regimes)):
            if regimes[i] != regimes[i-1]:
                mudancas += 1
        
        print(f"\nMudanças de regime: {mudancas}")
        if len(regimes) > 1:
            print(f"Estabilidade: {((len(regimes) - mudancas) / len(regimes)) * 100:.1f}%")
    
    def _analyze_snapshots(self, snapshot_data):
        """Análise dos snapshots de mercado"""
        print(f"\n📸 ANÁLISE DE SNAPSHOTS:")
        print(f"-" * 40)
        
        if not snapshot_data:
            print("Nenhum snapshot disponível")
            return
        
        print(f"Total de snapshots: {len(snapshot_data)}")
        
        # Evolução do volume
        volumes = [s['market_stats']['volume_total'] for s in snapshot_data]
        contratos = [s['market_stats']['contratos_total'] for s in snapshot_data]
        
        print(f"Volume final: R$ {volumes[-1]:,.0f}")
        print(f"Contratos finais: {contratos[-1]:,}")
        
        if len(volumes) > 1:
            growth_vol = ((volumes[-1] - volumes[0]) / volumes[0]) * 100 if volumes[0] > 0 else 0
            growth_cont = ((contratos[-1] - contratos[0]) / contratos[0]) * 100 if contratos[0] > 0 else 0
            
            print(f"Crescimento volume: {growth_vol:+.1f}%")
            print(f"Crescimento contratos: {growth_cont:+.1f}%")
    
    def export_ml_dataset(self, session_id, output_file=None):
        """
        Exporta dataset estruturado para machine learning
        
        Args:
            session_id: ID da sessão
            output_file: Arquivo de saída (opcional)
            
        Returns:
            DataFrame com features estruturadas
        """
        print(f"🤖 EXPORTANDO DATASET ML - SESSÃO: {session_id}")
        
        data = self.load_session_data(session_id)
        
        # Criar features estruturadas
        features_list = []
        
        if 'snapshots' in data and len(data['snapshots']) > 0:
            for i, snapshot in enumerate(data['snapshots']):
                features = {
                    'snapshot_id': i,
                    'timestamp': snapshot['timestamp'],
                    
                    # Features de mercado
                    'volume_total': snapshot['market_stats']['volume_total'],
                    'contratos_total': snapshot['market_stats']['contratos_total'],
                    'trades_total': snapshot['market_stats']['trades_total'],
                    'corretoras_ativas': snapshot['market_stats']['total_corretoras_ativas'],
                    
                    # Features de temperatura
                    'temperatura': snapshot['temperatura']['temperatura_geral']['temperatura'],
                    'temp_classificacao': snapshot['temperatura']['temperatura_geral']['classificacao'],
                    'temp_institucional': snapshot['temperatura']['por_categoria']['institucional']['temperatura'],
                    'temp_varejo': snapshot['temperatura']['por_categoria']['varejo']['temperatura'],
                    
                    # Features de fluxo
                    'fluxo_institucional_pct': snapshot['fluxo']['percentual_institucional'],
                    'fluxo_varejo_pct': snapshot['fluxo']['percentual_varejo'],
                    'fluxo_outros_pct': snapshot['fluxo']['percentual_outros'],
                    'fluxo_dominio': snapshot['fluxo']['dominio'],
                    
                    # Features de regime
                    'regime': snapshot['regime']['regime'],
                    'regime_confianca': snapshot['regime']['confianca']
                }
                
                features_list.append(features)
        
        # Criar DataFrame
        df_ml = pd.DataFrame(features_list)
        
        # Verificar se há dados antes de processar
        if len(df_ml) == 0:
            print("AVISO: Nenhum snapshot disponivel para criar dataset ML")
            # Criar DataFrame vazio com estrutura básica
            df_ml = pd.DataFrame(columns=[
                'snapshot_id', 'timestamp', 'volume_total', 'contratos_total', 
                'trades_total', 'corretoras_ativas', 'temperatura', 'temp_classificacao',
                'temp_institucional', 'temp_varejo', 'fluxo_institucional_pct',
                'fluxo_varejo_pct', 'fluxo_outros_pct', 'fluxo_dominio',
                'regime', 'regime_confianca'
            ])
        else:
            # Processar timestamps apenas se há dados
            df_ml['timestamp'] = pd.to_datetime(df_ml['timestamp'], format='mixed')
            
            # Adicionar features derivadas
            if len(df_ml) > 1:
                df_ml['volume_delta'] = df_ml['volume_total'].diff()
                df_ml['temp_delta'] = df_ml['temperatura'].diff()
                df_ml['contratos_delta'] = df_ml['contratos_total'].diff()
        
        # Salvar se especificado
        if output_file:
            df_ml.to_csv(output_file, index=False)
            print(f"Dataset salvo em: {output_file}")
        
        print(f"Dataset criado: {len(df_ml)} amostras x {len(df_ml.columns)} features")
        
        return df_ml
    
    def get_latest_session(self):
        """Retorna a sessão mais recente"""
        if not self.sessions:
            return None
        
        # Ordenar sessões por timestamp
        sorted_sessions = sorted(self.sessions.keys(), reverse=True)
        return sorted_sessions[0]

def main():
    """Exemplo de uso do analisador"""
    
    analyzer = DataAnalyzer()
    
    # Listar todas as sessões
    analyzer.list_sessions()
    
    # Analisar a sessão mais recente
    latest_session = analyzer.get_latest_session()
    if latest_session:
        print(f"\n🔍 Analisando sessão mais recente: {latest_session}")
        analyzer.analyze_session(latest_session)
        
        # Exportar dataset para ML
        df_ml = analyzer.export_ml_dataset(latest_session, f"ml_dataset_{latest_session}.csv")
        
        print(f"\nRESUMO DO DATASET ML:")
        print(df_ml.describe())
    else:
        print("ERRO: Nenhuma sessao encontrada!")

if __name__ == "__main__":
    main()