Initial commit: Refatoração completa do sistema de análise de mercado com IA

app.py

@@ -0,0 +1,580 @@
+"""Aplicação de Análise de Mercado com IA para Scalping - Versão Refatorada."""
+
+from typing import Dict, Any, Optional
+import gradio as gr
+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
+except ImportError:
+    # Fallback para modo standalone se módulos não existirem
+    print("⚠️ Módulos refatorados não encontrados. Executando em modo standalone.")
+    AppConfig = None
+    TechnicalAnalysisEngine = None
+    SentimentAnalysisEngine = None
+    GradioInterface = None
+    LogUtils = None
+    ValidationUtils = None
+
+# Engines de análise
+technical_engine = None
+sentiment_engine = None
+model_info = {'available': False, 'description': 'IA Indisponível'}
+
+# Inicializar engines
+def initialize_engines():
+    """Inicializa engines de análise técnica e de sentimento."""
+    global technical_engine, sentiment_engine, model_info
+    
+    try:
+        if TechnicalAnalysisEngine and SentimentAnalysisEngine:
+            # Inicializar engine de análise técnica
+            technical_engine = TechnicalAnalysisEngine()
+            if LogUtils:
+                LogUtils.log_analysis_result({'action': 'ENGINE_INIT', 'confidence': 100})
+            
+            # Inicializar engine de análise de sentimento
+            sentiment_engine = SentimentAnalysisEngine()
+            
+            # Obter informações do modelo de IA
+            model_info = sentiment_engine.get_model_info()
+            if LogUtils:
+                LogUtils.log_model_status(model_info)
+            
+            print("✅ Engines inicializadas com sucesso")
+        else:
+            # Fallback para modo standalone
+            initialize_standalone_mode()
+            
+    except Exception as e:
+        print(f"Erro na inicialização: {str(e)}")
+        # Fallback para modo básico
+        initialize_standalone_mode()
+
+def initialize_standalone_mode():
+    """Inicializa modo standalone com funcionalidades básicas."""
+    global model_info
+    
+    # Importações opcionais para IA
+    try:
+        from transformers import AutoTokenizer, AutoModelForSequenceClassification, pipeline
+        import torch
+        TRANSFORMERS_AVAILABLE = True
+    except ImportError:
+        TRANSFORMERS_AVAILABLE = False
+        print("⚠️ Transformers não disponível. Executando sem IA.")
+    
+    # Lista de modelos alternativos (do mais específico para o mais geral)
+    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"}
+        }
+    ]
+    
+    # Inicializar modelo de sentimento
+    sentiment_pipeline = None
+    current_model_info = None
+    
+    if TRANSFORMERS_AVAILABLE:
+        for model_config in FINANCIAL_MODELS:
+            try:
+                print(f"🔄 Tentando carregar: {model_config['description']}")
+                sentiment_pipeline = pipeline(
+                    "sentiment-analysis", 
+                    model=model_config["name"],
+                    return_all_scores=True
+                )
+                current_model_info = model_config
+                print(f"✅ {model_config['description']} carregado com sucesso!")
+                break
+            except Exception as e:
+                print(f"❌ Falha ao carregar {model_config['name']}: {e}")
+                continue
+        
+        if sentiment_pipeline is None:
+            print("❌ Nenhum modelo de sentimento pôde ser carregado.")
+            TRANSFORMERS_AVAILABLE = False
+    else:
+        print("⚠️ Transformers não disponível. Executando sem análise de sentimento IA.")
+    
+    # Atualizar model_info global
+    if current_model_info:
+        model_info = {'available': True, 'description': current_model_info['description']}
+    else:
+        model_info = {'available': False, 'description': 'IA Indisponível'}
+
+def parse_market_data(text):
+    """Extrai dados de mercado do texto de entrada usando engines ou fallback."""
+    if technical_engine and hasattr(technical_engine, 'parse_market_data'):
+        return technical_engine.parse_market_data(text)
+    
+    # Fallback para modo standalone
+    import re
+    try:
+        # Regex patterns para extrair dados
+        price_match = re.search(r'P:([0-9,]+\.?\d*)', text)
+        variation_match = re.search(r'\(([\+\-]\d+\.?\d*%?)\)', text)
+        rsi_match = re.search(r'RSI:(\d+)', text)
+        ema_match = re.search(r'EMA:(ALTA|BAIXA)', text)
+        bb_match = re.search(r'BB:(DENTRO|SOBRE|ABAIXO|ACIMA)', text)
+        vol_match = re.search(r'Vol:([0-9\.]+)', text)
+        
+        # Extrair valores
+        price = float(price_match.group(1).replace(',', '')) if price_match else 0
+        variation_str = variation_match.group(1) if variation_match else "0"
+        variation = float(variation_str.replace('%', '').replace('+', '')) if variation_str != "0" else 0
+        rsi = int(rsi_match.group(1)) if rsi_match else 50
+        ema_trend = ema_match.group(1) if ema_match else "NEUTRO"
+        bb_position = bb_match.group(1) if bb_match else "DENTRO"
+        volume = float(vol_match.group(1)) if vol_match else 0
+        
+        return {
+            'price': price,
+            'variation': variation,
+            'rsi': rsi,
+            'ema_trend': ema_trend,
+            'bb_position': bb_position,
+            'volume': volume
+        }
+    except Exception as e:
+        return None
+
+def analyze_sentiment(text):
+    """Analisa o sentimento do texto usando engines ou fallback."""
+    if sentiment_engine and hasattr(sentiment_engine, 'analyze_sentiment'):
+        return sentiment_engine.analyze_sentiment(text)
+    
+    # Fallback para modo standalone
+    import re
+    
+    # Verificar se temos pipeline carregado no modo standalone
+    if 'sentiment_pipeline' in globals() and sentiment_pipeline is not None:
+        try:
+            # Limpar e preparar o texto para análise
+            clean_text = re.sub(r'[^\w\s\+\-\%\.]', ' ', text)
+            clean_text = clean_text[:512]  # Limitar tamanho para o modelo
+            
+            result = sentiment_pipeline(clean_text)
+            
+            # Processar resultado baseado no modelo
+            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
+                if 'current_model_info' in globals() and current_model_info and label in current_model_info['labels']:
+                    sentiment_label = current_model_info['labels'][label]
+                else:
+                    # Fallback para mapeamento genérico
+                    label_lower = label.lower()
+                    if 'neg' in label_lower:
+                        sentiment_label = 'NEGATIVO'
+                    elif 'pos' in label_lower:
+                        sentiment_label = 'POSITIVO'
+                    else:
+                        sentiment_label = 'NEUTRO'
+                
+                return {
+                    'sentiment': label.lower(),
+                    'confidence': confidence,
+                    'label': sentiment_label
+                }
+            
+        except Exception as e:
+            print(f"Erro na análise de sentimento: {e}")
+    
+    # Fallback padrão
+    return {
+        'sentiment': 'neutral',
+        'confidence': 0.5,
+        'label': 'NEUTRO'
+    }
+
+def analyze_scalping_signals(market_data, original_text=""):
+    """Analisa sinais para scalping usando engines ou fallback."""
+    if technical_engine and hasattr(technical_engine, 'analyze_scalping_signals'):
+        return technical_engine.analyze_scalping_signals(market_data, original_text)
+    
+    # Fallback para modo standalone
+    if not market_data:
+        return {
+            'action': 'AGUARDAR',
+            'confidence': 0,
+            'signals': [],
+            'market_data': {},
+            'sentiment': {'label': 'NEUTRO', 'confidence': 0.5}
+        }
+    
+    # Análise de sentimento com FinBERT
+    sentiment_analysis = analyze_sentiment(original_text)
+    
+    price = market_data['price']
+    variation = market_data['variation']
+    rsi = market_data['rsi']
+    ema_trend = market_data['ema_trend']
+    bb_position = market_data['bb_position']
+    volume = market_data['volume']
+    
+    # Pontuação de confiança
+    confidence_score = 0
+    signals = []
+    action = 'AGUARDAR'
+    
+    # === ANÁLISE RSI ===
+    if rsi <= 30:  # Oversold
+        signals.append("RSI em zona de sobrevenda ({}): COMPRA".format(rsi))
+        confidence_score += 25
+        if action == 'AGUARDAR':
+            action = 'COMPRAR'
+    elif rsi >= 70:  # Overbought
+        signals.append("RSI em zona de sobrecompra ({}): VENDA".format(rsi))
+        confidence_score += 25
+        if action == 'AGUARDAR':
+            action = 'VENDER'
+    elif 45 <= rsi <= 55:
+        signals.append("RSI neutro ({}): aguardar confirmação".format(rsi))
+    
+    # === ANÁLISE EMA ===
+    if ema_trend == 'ALTA':
+        signals.append("Tendência EMA ALTA: viés de COMPRA")
+        confidence_score += 15
+        if action == 'VENDER':
+            confidence_score -= 10  # Conflito
+        elif action == 'AGUARDAR':
+            action = 'COMPRAR'
+    elif ema_trend == 'BAIXA':
+        signals.append("Tendência EMA BAIXA: viés de VENDA")
+        confidence_score += 15
+        if action == 'COMPRAR':
+            confidence_score -= 10  # Conflito
+        elif action == 'AGUARDAR':
+            action = 'VENDER'
+    
+    # === ANÁLISE BOLLINGER BANDS ===
+    if bb_position == 'ABAIXO':
+        signals.append("Preço abaixo da banda inferior: COMPRA (reversão)")
+        confidence_score += 20
+        if action == 'AGUARDAR':
+            action = 'COMPRAR'
+    elif bb_position == 'ACIMA' or bb_position == 'SOBRE':
+        signals.append("Preço acima da banda superior: VENDA (reversão)")
+        confidence_score += 20
+        if action == 'AGUARDAR':
+            action = 'VENDER'
+    elif bb_position == 'DENTRO':
+        signals.append("Preço dentro das bandas: aguardar breakout")
+        confidence_score += 5
+    
+    # === ANÁLISE DE MOMENTUM (Variação) ===
+    if abs(variation) >= 0.05:  # Movimento significativo
+        if variation > 0:
+            signals.append("Momentum positivo (+{:.2f}%): seguir tendência".format(variation))
+            confidence_score += 10
+            if action == 'VENDER':
+                confidence_score -= 5
+        else:
+            signals.append("Momentum negativo ({:.2f}%): seguir tendência".format(variation))
+            confidence_score += 10
+            if action == 'COMPRAR':
+                confidence_score -= 5
+    
+    # === ANÁLISE DE VOLUME ===
+    if volume > 1.0:  # Volume alto
+        signals.append("Volume alto ({:.1f}x): confirma movimento".format(volume))
+        confidence_score += 10
+    elif volume < 0.5:  # Volume baixo
+        signals.append("Volume baixo ({:.1f}x): cuidado com falsos sinais".format(volume))
+        confidence_score -= 5
+    
+    # === ANÁLISE DE SENTIMENTO IA (FinBERT) ===
+    sentiment_label = sentiment_analysis['label']
+    sentiment_conf = sentiment_analysis['confidence']
+    
+    if sentiment_label == 'POSITIVO':
+        signals.append("🤖 IA Sentimento: POSITIVO ({:.1f}%): viés de COMPRA".format(sentiment_conf * 100))
+        confidence_score += int(sentiment_conf * 20)  # Até 20 pontos
+        if action == 'AGUARDAR':
+            action = 'COMPRAR'
+        elif action == 'VENDER':
+            confidence_score -= 10  # Conflito com sentimento
+    elif sentiment_label == 'NEGATIVO':
+        signals.append("🤖 IA Sentimento: NEGATIVO ({:.1f}%): viés de VENDA".format(sentiment_conf * 100))
+        confidence_score += int(sentiment_conf * 20)  # Até 20 pontos
+        if action == 'AGUARDAR':
+            action = 'VENDER'
+        elif action == 'COMPRAR':
+            confidence_score -= 10  # Conflito com sentimento
+    else:
+        signals.append("🤖 IA Sentimento: NEUTRO ({:.1f}%): sem viés claro".format(sentiment_conf * 100))
+    
+    # === REGRAS ESPECÍFICAS DE SCALPING ===
+    
+    # Scalping: RSI extremo + EMA contrária = reversão forte
+    if (rsi <= 25 and ema_trend == 'BAIXA') or (rsi >= 75 and ema_trend == 'ALTA'):
+        signals.append("🚨 SINAL FORTE: RSI extremo com EMA contrária - REVERSÃO")
+        confidence_score += 30
+    
+    # Scalping: RSI + BB alinhados
+    if rsi <= 35 and bb_position == 'ABAIXO':
+        signals.append("🎯 SETUP PERFEITO: RSI baixo + BB abaixo - COMPRA FORTE")
+        confidence_score += 35
+        action = 'COMPRAR'
+    elif rsi >= 65 and (bb_position == 'ACIMA' or bb_position == 'SOBRE'):
+        signals.append("🎯 SETUP PERFEITO: RSI alto + BB acima - VENDA FORTE")
+        confidence_score += 35
+        action = 'VENDER'
+    
+    # Limitar confiança
+    confidence_score = min(confidence_score, 95)
+    confidence_score = max(confidence_score, 10)
+    
+    return {
+        'action': action,
+        'confidence': confidence_score,
+        'signals': signals,
+        'market_data': market_data,
+        'sentiment': sentiment_analysis
+    }
+
+def generate_trading_response(analysis):
+    """Gera resposta formatada para trading com análise de sentimento IA"""
+    
+    action = analysis['action']
+    confidence = analysis['confidence']
+    signals = analysis.get('signals', [])
+    market_data = analysis.get('market_data', {})
+    sentiment = analysis.get('sentiment', {'label': 'NEUTRO', 'confidence': 0.5})
+    
+    # Emojis e cores baseados na ação
+    if action == 'COMPRAR':
+        emoji = "🟢"
+        action_emoji = "📈"
+        color = "verde"
+        direction = "LONG"
+    elif action == 'VENDER':
+        emoji = "🔴"
+        action_emoji = "📉"
+        color = "vermelho"
+        direction = "SHORT"
+    else:
+        emoji = "🟡"
+        action_emoji = "⏸️"
+        color = "amarelo"
+        direction = "NEUTRO"
+    
+    # Emojis para sentimento
+    sentiment_emojis = {
+        'POSITIVO': '😊💚',
+        'NEGATIVO': '😟💔', 
+        'NEUTRO': '😐💛'
+    }
+    
+    # Barra de confiança
+    confidence_bars = "█" * int(confidence / 10) + "░" * (10 - int(confidence / 10))
+    
+    # Classificação de confiança
+    if confidence >= 80:
+        conf_level = "MUITO ALTA"
+    elif confidence >= 65:
+        conf_level = "ALTA"
+    elif confidence >= 50:
+        conf_level = "MODERADA"
+    else:
+        conf_level = "BAIXA"
+    
+    # Timestamp
+    timestamp = datetime.now().strftime("%H:%M:%S")
+    
+    response = f"""{emoji} **ANÁLISE SCALPING - WIN M1/M5**
+
+**⏰ Timestamp:** {timestamp}
+**📊 Instrumento:** WINV25
+
+**🎯 DECISÃO DE TRADING:**
+• **Ação:** {action} {action_emoji}
+• **Direção:** {direction}
+• **Confiança:** {confidence:.0f}% ({conf_level})
+• **Visual:** {confidence_bars}
+
+**🤖 ANÁLISE DE SENTIMENTO IA (FinBERT):**
+• **Sentimento:** {sentiment_emojis.get(sentiment['label'], '😐💛')} **{sentiment['label']}** ({sentiment['confidence']*100:.1f}%)
+
+**📈 DADOS DE MERCADO:**
+• **Preço:** {market_data.get('price', 'N/A'):,.0f}
+• **Variação:** {market_data.get('variation', 0):+.2f}%
+• **RSI:** {market_data.get('rsi', 'N/A')} 
+• **EMA:** {market_data.get('ema_trend', 'N/A')}
+• **Bollinger:** {market_data.get('bb_position', 'N/A')}
+• **Volume:** {market_data.get('volume', 0):.1f}x
+
+**🔍 ANÁLISE TÉCNICA + IA:**"""
+    
+    for i, signal in enumerate(signals[:5], 1):  # Máximo 5 sinais
+        response += f"\n{i}. {signal}"
+    
+    # Recomendações específicas
+    response += f"\n\n**⚡ RECOMENDAÇÕES SCALPING:**"
+    
+    if action == 'COMPRAR':
+        response += f"""
+• **Stop Loss:** -{market_data.get('price', 0) * 0.0007:.0f} pts (0.07%)
+• **Take Profit:** +{market_data.get('price', 0) * 0.0015:.0f} pts (0.15%)
+• **Timeframe:** M1/M5
+• **Risk/Reward:** 1:2"""
+    elif action == 'VENDER':
+        response += f"""
+• **Stop Loss:** +{market_data.get('price', 0) * 0.0007:.0f} pts (0.07%)
+• **Take Profit:** -{market_data.get('price', 0) * 0.0015:.0f} pts (0.15%)
+• **Timeframe:** M1/M5
+• **Risk/Reward:** 1:2"""
+    else:
+        response += """
+• **Aguardar:** Setup mais definido
+• **Monitorar:** Rompimentos de suporte/resistência
+• **Observar:** Confluência de sinais técnicos"""
+    
+    if confidence < 60:
+        response += f"\n\n⚠️ **ATENÇÃO:** Confiança {conf_level} - Aguarde confirmação adicional!"
+    
+    response += f"\n\n---\n*🤖 Análise Scalping Automatizada - {timestamp}*"
+    
+    return response
+
+def process_trading_analysis(text):
+    """Função principal que processa a análise de trading usando engines ou fallback."""
+    
+    # Validação de entrada
+    if ValidationUtils and hasattr(ValidationUtils, 'validate_text_input'):
+        if not ValidationUtils.validate_text_input(text):
+            return "⚠️ **Erro:** Entrada de texto inválida ou muito curta."
+    else:
+        # Fallback validation
+        if not text or not text.strip():
+            return "⚠️ **Erro:** Nenhum dado de mercado fornecido para análise."
+    
+    try:
+        # Parse dos dados de mercado
+        market_data = parse_market_data(text)
+        
+        if not market_data:
+            return "⚠️ **Erro:** Não foi possível extrair dados válidos do texto fornecido."
+        
+        # Análise dos sinais de scalping
+        analysis = analyze_scalping_signals(market_data, text)
+        
+        # Log da análise se disponível
+        if LogUtils and hasattr(LogUtils, 'log_analysis_result'):
+            LogUtils.log_analysis_result(analysis)
+        
+        # Gerar resposta formatada para a interface
+        return generate_trading_response(analysis)
+        
+    except Exception as e:
+        error_msg = f"Erro durante a análise: {str(e)}"
+        if LogUtils and hasattr(LogUtils, 'log_error'):
+            LogUtils.log_error(error_msg, "PROCESS_ANALYSIS")
+        
+        return f"❌ **Erro:** {error_msg}"
+
+# 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."""
+    result = process_trading_analysis(text)
+    
+    # Se o resultado é uma string (erro ou resposta formatada), retornar diretamente
+    if isinstance(result, str):
+        return result
+    
+    # Se é um dicionário (análise estruturada), formatar para string
+    if isinstance(result, dict):
+        return generate_trading_response(result)
+    
+    return "❌ **Erro:** Resultado de análise inválido."
+
+# Criar e configurar interface
+def create_interface():
+    """Cria interface usando a nova arquitetura modular."""
+    if GradioInterface:
+        # Usar interface refatorada
+        interface = GradioInterface(
+            analysis_function=main_analysis_function,
+            model_info=model_info
+        )
+        return interface.create_interface()
+    else:
+        # Fallback para interface simples
+        return create_fallback_interface()
+
+def create_fallback_interface():
+    """Cria interface simples para modo standalone."""
+    example_data = AppConfig.EXAMPLE_INPUT if AppConfig else """IBOV: 129.847 (+0,85%)
+RSI: 65
+EMA 9: Tendência de alta
+Bollinger: Preço próximo à banda superior
+Volume: 2.3x da média
+Notícias: Mercado otimista com dados do PIB"""
+    
+    with gr.Blocks(title="📈 Análise de Mercado IA") as interface:
+        gr.HTML("""
+        <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;">📈 Análise de Mercado IA</h1>
+            <p style="color: #f0f0f0; margin: 10px 0 0 0;">Sistema de análise técnica para scalping</p>
+        </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()
+        
+        analyze_btn.click(
+            fn=main_analysis_function,
+            inputs=[market_input],
+            outputs=[result_output]
+        )
+    
+    return interface
+
+# Inicializar engines e criar interface
+initialize_engines()
+demo = create_interface()
+
+if __name__ == "__main__":
+    demo.launch()

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'
+    }

market_analysis.py

@@ -0,0 +1,427 @@
+"""Módulo de análise técnica de mercado para scalping."""
+
+import re
+from typing import Dict, List, Optional, Any
+from dataclasses import dataclass
+from datetime import datetime
+
+from config import (
+    TechnicalAnalysisConfig,
+    ScoringConfig,
+    TradingConfig,
+    RegexPatterns
+)
+
+
+@dataclass
+class MarketData:
+    """Classe para representar dados de mercado."""
+    price: float
+    variation: float
+    rsi: int
+    ema_trend: str
+    bb_position: str
+    volume: float
+    
+    def __post_init__(self):
+        """Validação dos dados após inicialização."""
+        if self.price < 0:
+            raise ValueError("Preço não pode ser negativo")
+        if not 0 <= self.rsi <= 100:
+            raise ValueError("RSI deve estar entre 0 e 100")
+        if self.volume < 0:
+            raise ValueError("Volume não pode ser negativo")
+
+
+@dataclass
+class TechnicalSignal:
+    """Classe para representar um sinal técnico."""
+    indicator: str
+    signal_type: str  # 'BUY', 'SELL', 'NEUTRAL'
+    strength: int  # 0-100
+    description: str
+    confidence_impact: int
+
+
+class MarketDataParser:
+    """Classe responsável por extrair dados de mercado do texto."""
+    
+    @staticmethod
+    def parse_market_data(text: str) -> Optional[MarketData]:
+        """Extrai dados de mercado do texto de entrada."""
+        try:
+            # Extrair valores usando regex
+            price_match = re.search(RegexPatterns.PRICE_PATTERN, text)
+            variation_match = re.search(RegexPatterns.VARIATION_PATTERN, text)
+            rsi_match = re.search(RegexPatterns.RSI_PATTERN, text)
+            ema_match = re.search(RegexPatterns.EMA_PATTERN, text)
+            bb_match = re.search(RegexPatterns.BB_PATTERN, text)
+            vol_match = re.search(RegexPatterns.VOLUME_PATTERN, text)
+            
+            # Processar valores extraídos
+            price = float(price_match.group(1).replace(',', '')) if price_match else 0
+            
+            variation_str = variation_match.group(1) if variation_match else "0"
+            variation = float(variation_str.replace('%', '').replace('+', '')) if variation_str != "0" else 0
+            
+            rsi = int(rsi_match.group(1)) if rsi_match else 50
+            ema_trend = ema_match.group(1) if ema_match else "NEUTRO"
+            bb_position = bb_match.group(1) if bb_match else "DENTRO"
+            volume = float(vol_match.group(1)) if vol_match else 0
+            
+            return MarketData(
+                price=price,
+                variation=variation,
+                rsi=rsi,
+                ema_trend=ema_trend,
+                bb_position=bb_position,
+                volume=volume
+            )
+            
+        except (ValueError, AttributeError) as e:
+            print(f"Erro ao processar dados de mercado: {e}")
+            return None
+
+
+class RSIAnalyzer:
+    """Analisador de RSI."""
+    
+    @staticmethod
+    def analyze(rsi: int) -> TechnicalSignal:
+        """Analisa o RSI e retorna sinal técnico."""
+        config = TechnicalAnalysisConfig()
+        
+        if rsi <= config.RSI_OVERSOLD:
+            if rsi <= config.RSI_EXTREME_OVERSOLD:
+                return TechnicalSignal(
+                    indicator="RSI",
+                    signal_type="BUY",
+                    strength=90,
+                    description=f"RSI em zona de sobrevenda extrema ({rsi}): COMPRA FORTE",
+                    confidence_impact=ScoringConfig.RSI_SCORE + 10
+                )
+            else:
+                return TechnicalSignal(
+                    indicator="RSI",
+                    signal_type="BUY",
+                    strength=70,
+                    description=f"RSI em zona de sobrevenda ({rsi}): COMPRA",
+                    confidence_impact=ScoringConfig.RSI_SCORE
+                )
+        
+        elif rsi >= config.RSI_OVERBOUGHT:
+            if rsi >= config.RSI_EXTREME_OVERBOUGHT:
+                return TechnicalSignal(
+                    indicator="RSI",
+                    signal_type="SELL",
+                    strength=90,
+                    description=f"RSI em zona de sobrecompra extrema ({rsi}): VENDA FORTE",
+                    confidence_impact=ScoringConfig.RSI_SCORE + 10
+                )
+            else:
+                return TechnicalSignal(
+                    indicator="RSI",
+                    signal_type="SELL",
+                    strength=70,
+                    description=f"RSI em zona de sobrecompra ({rsi}): VENDA",
+                    confidence_impact=ScoringConfig.RSI_SCORE
+                )
+        
+        elif config.RSI_NEUTRAL_MIN <= rsi <= config.RSI_NEUTRAL_MAX:
+            return TechnicalSignal(
+                indicator="RSI",
+                signal_type="NEUTRAL",
+                strength=30,
+                description=f"RSI neutro ({rsi}): aguardar confirmação",
+                confidence_impact=0
+            )
+        
+        else:
+            return TechnicalSignal(
+                indicator="RSI",
+                signal_type="NEUTRAL",
+                strength=50,
+                description=f"RSI em zona intermediária ({rsi})",
+                confidence_impact=0
+            )
+
+
+class EMAAnalyzer:
+    """Analisador de EMA."""
+    
+    @staticmethod
+    def analyze(ema_trend: str) -> TechnicalSignal:
+        """Analisa a tendência EMA e retorna sinal técnico."""
+        if ema_trend == 'ALTA':
+            return TechnicalSignal(
+                indicator="EMA",
+                signal_type="BUY",
+                strength=60,
+                description="Tendência EMA ALTA: viés de COMPRA",
+                confidence_impact=ScoringConfig.EMA_SCORE
+            )
+        elif ema_trend == 'BAIXA':
+            return TechnicalSignal(
+                indicator="EMA",
+                signal_type="SELL",
+                strength=60,
+                description="Tendência EMA BAIXA: viés de VENDA",
+                confidence_impact=ScoringConfig.EMA_SCORE
+            )
+        else:
+            return TechnicalSignal(
+                indicator="EMA",
+                signal_type="NEUTRAL",
+                strength=30,
+                description="Tendência EMA neutra",
+                confidence_impact=0
+            )
+
+
+class BollingerBandsAnalyzer:
+    """Analisador de Bollinger Bands."""
+    
+    @staticmethod
+    def analyze(bb_position: str) -> TechnicalSignal:
+        """Analisa a posição nas Bollinger Bands e retorna sinal técnico."""
+        if bb_position == 'ABAIXO':
+            return TechnicalSignal(
+                indicator="BB",
+                signal_type="BUY",
+                strength=80,
+                description="Preço abaixo da banda inferior: COMPRA (reversão)",
+                confidence_impact=ScoringConfig.BB_SCORE
+            )
+        elif bb_position in ['ACIMA', 'SOBRE']:
+            return TechnicalSignal(
+                indicator="BB",
+                signal_type="SELL",
+                strength=80,
+                description="Preço acima da banda superior: VENDA (reversão)",
+                confidence_impact=ScoringConfig.BB_SCORE
+            )
+        else:  # DENTRO
+            return TechnicalSignal(
+                indicator="BB",
+                signal_type="NEUTRAL",
+                strength=40,
+                description="Preço dentro das bandas: aguardar breakout",
+                confidence_impact=5
+            )
+
+
+class MomentumAnalyzer:
+    """Analisador de momentum (variação de preço)."""
+    
+    @staticmethod
+    def analyze(variation: float) -> TechnicalSignal:
+        """Analisa o momentum e retorna sinal técnico."""
+        config = TechnicalAnalysisConfig()
+        
+        if abs(variation) >= config.SIGNIFICANT_MOVEMENT_THRESHOLD:
+            if variation > 0:
+                return TechnicalSignal(
+                    indicator="MOMENTUM",
+                    signal_type="BUY",
+                    strength=60,
+                    description=f"Momentum positivo (+{variation:.2f}%): seguir tendência",
+                    confidence_impact=ScoringConfig.MOMENTUM_SCORE
+                )
+            else:
+                return TechnicalSignal(
+                    indicator="MOMENTUM",
+                    signal_type="SELL",
+                    strength=60,
+                    description=f"Momentum negativo ({variation:.2f}%): seguir tendência",
+                    confidence_impact=ScoringConfig.MOMENTUM_SCORE
+                )
+        else:
+            return TechnicalSignal(
+                indicator="MOMENTUM",
+                signal_type="NEUTRAL",
+                strength=30,
+                description=f"Momentum fraco ({variation:.2f}%)",
+                confidence_impact=0
+            )
+
+
+class VolumeAnalyzer:
+    """Analisador de volume."""
+    
+    @staticmethod
+    def analyze(volume: float) -> TechnicalSignal:
+        """Analisa o volume e retorna sinal técnico."""
+        config = TechnicalAnalysisConfig()
+        
+        if volume > config.VOLUME_HIGH_THRESHOLD:
+            return TechnicalSignal(
+                indicator="VOLUME",
+                signal_type="NEUTRAL",
+                strength=70,
+                description=f"Volume alto ({volume:.1f}x): confirma movimento",
+                confidence_impact=ScoringConfig.VOLUME_SCORE
+            )
+        elif volume < config.VOLUME_LOW_THRESHOLD:
+            return TechnicalSignal(
+                indicator="VOLUME",
+                signal_type="NEUTRAL",
+                strength=20,
+                description=f"Volume baixo ({volume:.1f}x): cuidado com falsos sinais",
+                confidence_impact=-ScoringConfig.LOW_VOLUME_PENALTY
+            )
+        else:
+            return TechnicalSignal(
+                indicator="VOLUME",
+                signal_type="NEUTRAL",
+                strength=50,
+                description=f"Volume normal ({volume:.1f}x)",
+                confidence_impact=0
+            )
+
+
+class ScalpingSetupDetector:
+    """Detector de setups específicos para scalping."""
+    
+    @staticmethod
+    def detect_perfect_setups(market_data: MarketData, signals: List[TechnicalSignal]) -> List[TechnicalSignal]:
+        """Detecta setups perfeitos para scalping."""
+        special_signals = []
+        config = TechnicalAnalysisConfig()
+        
+        # Setup 1: RSI extremo + EMA contrária = reversão forte
+        if ((market_data.rsi <= config.RSI_EXTREME_OVERSOLD and market_data.ema_trend == 'BAIXA') or 
+            (market_data.rsi >= config.RSI_EXTREME_OVERBOUGHT and market_data.ema_trend == 'ALTA')):
+            
+            special_signals.append(TechnicalSignal(
+                indicator="SETUP_REVERSAL",
+                signal_type="BUY" if market_data.rsi <= config.RSI_EXTREME_OVERSOLD else "SELL",
+                strength=95,
+                description="🚨 SINAL FORTE: RSI extremo com EMA contrária - REVERSÃO",
+                confidence_impact=ScoringConfig.STRONG_REVERSAL_BONUS
+            ))
+        
+        # Setup 2: RSI + BB alinhados
+        if market_data.rsi <= 35 and market_data.bb_position == 'ABAIXO':
+            special_signals.append(TechnicalSignal(
+                indicator="SETUP_PERFECT_BUY",
+                signal_type="BUY",
+                strength=100,
+                description="🎯 SETUP PERFEITO: RSI baixo + BB abaixo - COMPRA FORTE",
+                confidence_impact=ScoringConfig.PERFECT_SETUP_BONUS
+            ))
+        
+        elif market_data.rsi >= 65 and market_data.bb_position in ['ACIMA', 'SOBRE']:
+            special_signals.append(TechnicalSignal(
+                indicator="SETUP_PERFECT_SELL",
+                signal_type="SELL",
+                strength=100,
+                description="🎯 SETUP PERFEITO: RSI alto + BB acima - VENDA FORTE",
+                confidence_impact=ScoringConfig.PERFECT_SETUP_BONUS
+            ))
+        
+        return special_signals
+
+
+class TechnicalAnalysisEngine:
+    """Engine principal de análise técnica."""
+    
+    def __init__(self):
+        self.rsi_analyzer = RSIAnalyzer()
+        self.ema_analyzer = EMAAnalyzer()
+        self.bb_analyzer = BollingerBandsAnalyzer()
+        self.momentum_analyzer = MomentumAnalyzer()
+        self.volume_analyzer = VolumeAnalyzer()
+        self.setup_detector = ScalpingSetupDetector()
+    
+    def analyze(self, market_data: MarketData) -> Dict[str, Any]:
+        """Executa análise técnica completa."""
+        # Análises individuais
+        signals = [
+            self.rsi_analyzer.analyze(market_data.rsi),
+            self.ema_analyzer.analyze(market_data.ema_trend),
+            self.bb_analyzer.analyze(market_data.bb_position),
+            self.momentum_analyzer.analyze(market_data.variation),
+            self.volume_analyzer.analyze(market_data.volume)
+        ]
+        
+        # Detectar setups especiais
+        special_signals = self.setup_detector.detect_perfect_setups(market_data, signals)
+        all_signals = signals + special_signals
+        
+        # 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
+        }
+    
+    def _calculate_action_and_confidence(self, signals: List[TechnicalSignal]) -> tuple[str, int]:
+        """Calcula a ação recomendada e nível de confiança."""
+        buy_score = 0
+        sell_score = 0
+        confidence_score = 0
+        
+        # Somar pontuações por tipo de sinal
+        for signal in signals:
+            confidence_score += signal.confidence_impact
+            
+            if signal.signal_type == "BUY":
+                buy_score += signal.strength
+            elif signal.signal_type == "SELL":
+                sell_score += signal.strength
+        
+        # Determinar ação baseada nas pontuações
+        if buy_score > sell_score and buy_score > 100:
+            action = "COMPRAR"
+        elif sell_score > buy_score and sell_score > 100:
+            action = "VENDER"
+        else:
+            action = "AGUARDAR"
+        
+        # Aplicar penalidade por conflito
+        if abs(buy_score - sell_score) < 50 and max(buy_score, sell_score) > 100:
+            confidence_score -= ScoringConfig.CONFLICT_PENALTY
+        
+        # Limitar confiança
+        confidence_score = max(ScoringConfig.MIN_CONFIDENCE, 
+                             min(ScoringConfig.MAX_CONFIDENCE, confidence_score))
+        
+        return action, confidence_score
+
+
+class RiskCalculator:
+    """Calculadora de risco para trading."""
+    
+    @staticmethod
+    def calculate_stop_loss(price: float, action: str) -> float:
+        """Calcula stop loss baseado no preço e ação."""
+        config = TradingConfig()
+        stop_distance = price * config.STOP_LOSS_PERCENTAGE
+        
+        if action == "COMPRAR":
+            return price - stop_distance
+        elif action == "VENDER":
+            return price + stop_distance
+        else:
+            return 0
+    
+    @staticmethod
+    def calculate_take_profit(price: float, action: str) -> float:
+        """Calcula take profit baseado no preço e ação."""
+        config = TradingConfig()
+        profit_distance = price * config.TAKE_PROFIT_PERCENTAGE
+        
+        if action == "COMPRAR":
+            return price + profit_distance
+        elif action == "VENDER":
+            return price - profit_distance
+        else:
+            return 0
+    
+    @staticmethod
+    def get_risk_reward_ratio() -> float:
+        """Retorna a relação risco/recompensa configurada."""
+        return TradingConfig.RISK_REWARD_RATIO

requirements.txt

@@ -0,0 +1,6 @@
+gradio==4.44.0
+transformers==4.36.0
+torch>=2.0.0
+numpy>=1.24.0
+pandas>=2.0.0
+scipy>=1.11.0

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 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()

ui.py

@@ -0,0 +1,476 @@
+"""Módulo de interface do usuário com Gradio."""
+
+import gradio as gr
+from typing import Dict, Any, Optional, Tuple
+
+from config import UIConfig, AppConfig
+from utils import (
+    DateTimeUtils,
+    NumberUtils,
+    ConfidenceUtils,
+    ActionUtils,
+    SentimentUtils,
+    FormatUtils
+)
+
+
+class UIComponents:
+    """Componentes da interface do usuário."""
+    
+    @staticmethod
+    def create_header() -> str:
+        """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>
+            """)
+            
+            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"
+            )
+        
+        return input_section, market_input, analyze_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 Dados Brutos
+                with gr.Tab("🔍 Dados Detalhados"):
+                    outputs['raw_data'] = gr.JSON()
+        
+        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 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 = 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 evento 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['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, 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)
+            
+            # 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,
+                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': error_msg}
+            )
+    
+    def _get_custom_css(self) -> str:
+        """Retorna CSS customizado para a interface."""
+        return """
+        .gradio-container {
+            max-width: 1200px !important;
+            margin: auto !important;
+        }
+        
+        .gr-button {
+            transition: all 0.3s ease !important;
+        }
+        
+        .gr-button:hover {
+            transform: translateY(-2px) !important;
+            box-shadow: 0 4px 8px rgba(0,0,0,0.2) !important;
+        }
+        
+        .gr-textbox textarea {
+            font-family: 'Courier New', monospace !important;
+        }
+        
+        .gr-tab-nav {
+            background: #f8f9fa !important;
+        }
+        
+        .gr-tab-nav button {
+            border-radius: 8px 8px 0 0 !important;
+        }
+        """
+    
+    def launch(self, **kwargs) -> None:
+        """Lança a interface."""
+        if not self.interface:
+            self.create_interface()
+        
+        default_kwargs = {
+            'server_name': '127.0.0.1',
+            'server_port': 7860,
+            'share': False,
+            'show_error': True
+        }
+        
+        # Mesclar argumentos padrão com os fornecidos
+        launch_kwargs = {**default_kwargs, **kwargs}
+        
+        self.interface.launch(**launch_kwargs)

utils.py

@@ -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 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)
+        }