Primeiro commit

app.py

@@ -0,0 +1,244 @@
+import gradio as gr
+from datetime import datetime, timedelta
+import stocks as st
+
+
+class GradioInterface:
+    def __init__(self, pipeline):
+        self.pipeline = pipeline
+        self.strategy_params = {
+            'rsi_period': 14,
+            'rsi_upper': 70,
+            'rsi_lower': 30,
+            'sma_short': 50,
+            'sma_long': 200,
+            'max_loss_percent': 0.02,
+            'take_profit_percent': 0.05,
+            'position_size': 0.1,
+            'atr_period': 14,
+            'atr_multiplier': 3,
+            'confidence_threshold' : 0.7,
+            'sentiment_threshold' : 0.5
+        }
+        
+    def create_settings_interface(self):
+        with gr.Blocks() as settings_interface:
+            with gr.Row():
+                with gr.Column():
+                    # Parâmetros da Estratégia de Trading
+                    gr.Markdown("### Parâmetros da Estratégia de Trading")
+                    inputs = {}
+                    inputs['rsi_period'] = gr.Number(value=14, label="Período RSI")
+                    inputs['rsi_upper'] = gr.Number(value=70, label="Limite Superior RSI", minimum=0, maximum=100)
+                    inputs['rsi_lower'] = gr.Number(value=30, label="Limite Inferior RSI", minimum=0, maximum=100)
+                    inputs['sma_short'] = gr.Number(value=50, label="SMA Curta (período)")
+                    inputs['sma_long'] = gr.Number(value=200, label="SMA Longa (período)")
+                    inputs['max_loss_percent'] = gr.Slider(0, 0.5, value=0.02, step=0.01, label="Stop Loss (%)")
+                    inputs['take_profit_percent'] = gr.Slider(0, 0.5, value=0.05, step=0.01, label="Take Profit (%)")
+                    inputs['position_size'] = gr.Slider(0.01, 1.0, value=0.1, step=0.01, label="Tamanho da Posição (%)")
+                    inputs['atr_period'] = gr.Number(value=14, label="Período ATR")
+                    inputs['atr_multiplier'] = gr.Number(value=3, label="Multiplicador ATR")
+                    inputs['confidence_threshold'] = gr.Number(value=70, label="Nível de Confiança Mínima (%)", minimum=0, maximum=100)
+                    inputs['sentiment_threshold'] = gr.Number(value=50, label="Nível Sentimento Mínimo (%)", minimum=0, maximum=100)
+                    save_btn = gr.Button("Salvar Configurações")                    
+                    # Adicionando a explicação em Markdown
+                    gr.Markdown("""
+                    ## 📊 Explicação dos Parâmetros da Estratégia de Trading
+
+                    Esses parâmetros configuram indicadores técnicos para ajudar na decisão de compra e venda de ativos.
+
+                    ### **📉 RSI (Relative Strength Index)**
+                    O RSI é usado para medir a força do movimento de um ativo.
+
+                    - **`rsi_period` (14)** → Número de períodos para calcular o RSI (padrão: 14).
+                    - **`rsi_upper` (70)** → Se o RSI for maior que esse valor, pode indicar sobrecompra (sinal de venda).
+                    - **`rsi_lower` (30)** → Se o RSI for menor que esse valor, pode indicar sobrevenda (sinal de compra).
+
+                    ---
+
+                    ### **📈 Médias Móveis Simples (SMA - Simple Moving Average)**
+                    Indicadores que suavizam os preços ao longo do tempo.
+
+                    - **`sma_short` (50)** → Média móvel curta, usada para capturar tendências de curto prazo.
+                    - **`sma_long` (200)** → Média móvel longa, usada para capturar tendências de longo prazo.
+
+                    ---
+
+                    ### **📉 Gestão de Risco**
+
+                    - **`max_loss_percent` (0.02)** → Stop Loss (limite de perda). Se o preço cair mais que 2%, a posição é fechada.
+                    - **`take_profit_percent` (0.05)** → Take Profit (limite de lucro). Se o preço subir 5%, a posição é fechada.
+                    - **`position_size` (0.1)** → Proporção do capital total que será usado em uma operação (10% do saldo).
+
+                    ---
+
+                    ### **📊 ATR (Average True Range) - Volatilidade**
+                    O ATR é usado para medir a volatilidade do ativo.
+
+                    - **`atr_period` (14)** → Número de períodos para calcular o ATR.
+                    - **`atr_multiplier` (3)** → Multiplicador do ATR, geralmente usado para definir stop loss dinâmico.
+
+                    ---
+
+                    ## **🚀 Como esses parâmetros afetam a estratégia?**
+
+                    - **Se `rsi_lower` for menor (ex: 20), a estratégia comprará em regiões mais sobrevendidas.**
+                    - **Se `max_loss_percent` for muito pequeno, pode fechar trades prematuramente.**
+                    - **Se `atr_multiplier` for maior, o stop loss será mais amplo e permitirá mais volatilidade.**
+                    - **Se `sma_short` e `sma_long` estiverem distantes, as entradas serão mais conservadoras.**
+
+                    Se precisar ajustar os valores para um backtest, posso sugerir otimizações! 🚀
+                    """)
+  
+            save_btn.click(
+                self.save_settings,
+                inputs=[v for v in inputs.values()],
+                outputs=None
+            )
+        return settings_interface
+    
+    def save_settings(self, *args):
+        params = [
+            'rsi_period', 'rsi_upper', 'rsi_lower',
+            'sma_short', 'sma_long', 'max_loss_percent',
+            'take_profit_percent', 'position_size',
+            'atr_period', 'atr_multiplier', 'confidence_threshold', 'sentiment_threshold'
+        ]
+        
+        self.strategy_params = dict(zip(params, args))
+        print("Parâmetros atualizados:", self.strategy_params)
+        return gr.Info("Configurações salvas com sucesso!")
+    
+    def create_main_interface(self):
+        with gr.Blocks() as main_interface:
+            with gr.Row():
+                with gr.Column():
+                    ticker_input = gr.Text(label="Ticker (ex: AAPL)")
+                    api_key_input = gr.Textbox(label="API Key (opcional)", placeholder="Insira sua API Key https://newsapi.org/")
+                    fetch_new = gr.Dropdown([True, False], label="Buscar noticias online?", value=False)
+                    initial_investment = gr.Number(10000, label="Investimento Inicial (USD)")
+                    years_back = gr.Number(5, label="Período Histórico (anos)")
+                    commission = gr.Number(0.001, label="Comissão por Trade")
+                    run_btn = gr.Button("Executar Análise e Simulação")
+                with gr.Column():
+                    plot_output = gr.Plot()
+            with gr.Row():
+                # Adicionar uma saída para os resultados
+                output_md = gr.Markdown()
+                    
+            run_btn.click(
+                self.run_full_analysis,
+                inputs=[ticker_input, fetch_new, initial_investment, years_back, commission, api_key_input],
+                outputs=[output_md, plot_output]
+            )
+        return main_interface
+    
+    def run_full_analysis(self, ticker, fetch_new, initial_investment, years_back, commission, api_key):
+        # Atualizar os parâmetros da pipeline
+        self.pipeline.set_sentiment_threshold(float(self.strategy_params['sentiment_threshold'])/100)
+        self.pipeline.set_confidence_threshold(float(self.strategy_params['confidence_threshold'])/100)
+        
+        # Executar análise
+        result = self.pipeline.analyze_company(
+            ticker=ticker,
+            news_api_key=api_key,
+            fetch_new=fetch_new
+        )
+        
+        if not result:
+            return "Erro na análise", None
+            
+        # Configurar simulação
+        end_date = datetime.now()
+        start_date = end_date - timedelta(days=int(years_back*365))
+        
+        # Criar estratégia personalizada com os parâmetros
+        custom_strategy_params = {
+            'rsi_period': int(self.strategy_params['rsi_period']),
+            'rsi_upper': int(self.strategy_params['rsi_upper']),
+            'rsi_lower': int(self.strategy_params['rsi_lower']),
+            'sma_short': int(self.strategy_params['sma_short']),
+            'sma_long': int(self.strategy_params['sma_long']),
+            'max_loss_percent': float(self.strategy_params['max_loss_percent']),
+            'take_profit_percent': float(self.strategy_params['take_profit_percent']),
+            'position_size': float(self.strategy_params['position_size']),
+            'atr_period': int(self.strategy_params['atr_period']),
+            'atr_multiplier': int(self.strategy_params['atr_multiplier']),
+            'confidence_threshold' : float(self.strategy_params['confidence_threshold'])/100,
+            'sentiment_threshold' : float(self.strategy_params['sentiment_threshold'])/100
+        }
+        
+        # Criar uma instância de Progress
+        progress = gr.Progress()
+
+        # Atualizar progresso
+        progress(0.3, desc="Preparando simulação...")
+        
+        # Executar simulação
+        bt_integration = st.BacktraderIntegration(analysis_result=result,strategy_params=custom_strategy_params)
+        bt_integration.add_data_feed(ticker, start_date, end_date)
+            
+        progress(0.6, desc="Executando simulação...")
+           
+        final_value = bt_integration.run_simulation(
+            initial_cash=initial_investment,
+            commission=commission
+        )
+            
+        progress(0.9, desc="Gerando resultados...")
+            
+        # Extrair os valores do JSON de sentimento
+        sentiment = result['sentiment']['sentiment']
+        negative_sentiment = sentiment.get('negativo', 0.0)
+        neutral_sentiment = sentiment.get('neutral', 0.0)
+        positive_sentiment = sentiment.get('positive', 0.0)
+        
+        # Gerar saída formatada em Markdown
+        output = f"""
+        ## Recomendação: {result['recommendation']}
+        
+        **Confiança**: {result['confidence']['total_confidence']:.2%}  
+        **Retorno da Simulação**: {(final_value/initial_investment-1)*100:.2f}%  
+        
+        ### Detalhes:
+        
+        - **Sentimento Negativo**: {negative_sentiment:.2%}  
+        - **Sentimento Neutro**: {neutral_sentiment:.2%}  
+        - **Sentimento Positivo**: {positive_sentiment:.2%}  
+        
+        - **RSI**: {result['technical']['rsi']:.1f}  
+        - **Preço vs SMA50**: {result['technical']['price_vs_sma']:.2%}  
+        - **P/E Ratio**: {result['fundamental'].get('trailingPE', 'N/A')}  
+        """
+        # Gerar gráfico simples (exemplo)
+        plot = self.generate_simple_plot(bt_integration)
+        
+        return output, plot
+
+    
+    def generate_simple_plot(self, bt_integration):
+        # Implemente aqui a geração do gráfico usando matplotlib
+        import matplotlib.pyplot as plt
+        
+        plt.figure(figsize=(10, 6))
+        # Exemplo: Plotar preço de fechamento
+        data = bt_integration.cerebro.datas[0].close.array
+        plt.plot(data, label='Preço')
+        plt.title("Desempenho Histórico")
+        plt.legend()
+        return plt.gcf()
+
+# Configuração da interface completa
+pipeline = st.AnalysisPipeline()
+
+interface = GradioInterface(pipeline)
+
+demo = gr.TabbedInterface(
+    [interface.create_main_interface(), interface.create_settings_interface()],
+    ["Análise Principal", "Configurações da Estratégia"],
+    title="Stock Analyst Pro"
+)
+
+if __name__ == "__main__":
+    #demo.launch(share=True)
+    demo.launch()

requirements.txt

@@ -0,0 +1,12 @@
+gradio>=3.0.0
+matplotlib>=3.0.0
+pandas>=1.0.0
+numpy>=1.0.0
+backtrader>=1.9.0
+requests>=2.0.0
+python-dateutil>=2.8.0
+yfinance>=0.2.0
+torch>=1.0.0
+transformers>=4.0.0
+sqlalchemy>=1.4.0
+newsapi-python>=0.1.6

stocks.py

@@ -0,0 +1,668 @@
+import yfinance as yf
+import pandas as pd
+import numpy as np
+import torch
+import json
+from datetime import datetime, timedelta
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+from sqlalchemy import create_engine, Column, Integer, String, JSON
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+from newsapi import NewsApiClient
+from functools import lru_cache
+
+import backtrader as bt
+
+
+# 1. Configuração do Banco de Dados (FORA de qualquer classe)
+Base = declarative_base() 
+engine = create_engine('sqlite:///financial_data.db')
+Session = sessionmaker(bind=engine)
+
+# 2. Modelo de Dados (usa a Base declarada acima)
+class CompanyData(Base):
+    __tablename__ = 'company_data'
+    id = Column(Integer, primary_key=True)
+    ticker = Column(String)
+    data_type = Column(String)
+    data = Column(JSON)
+    date = Column(String)
+
+# 3. Criar tabelas (após definir todos os modelos)
+Base.metadata.create_all(engine)
+    
+# 4. Class for Financial Analyst
+class FinancialAnalyst:
+    def __init__(self):
+        self.models = {}
+        self.tokenizers = {}
+        # 2. LM Models for Financial Analysis
+        FINANCIAL_MODELS = {
+            'finbert': {
+                'model': "ProsusAI/finbert",
+                'tokenizer': "ProsusAI/finbert"
+            },
+            'financial_sentiment': {
+                'model': "mrm8488/distilroberta-finetuned-financial-news-sentiment-analysis",
+                'tokenizer': "mrm8488/distilroberta-finetuned-financial-news-sentiment-analysis"
+            }
+        }
+        
+        for name, config in FINANCIAL_MODELS.items():
+            try:
+                self.tokenizers[name] = AutoTokenizer.from_pretrained(config['tokenizer'])
+                # Use cache to avoid downloading the model multiple times
+                self.models[name] = self._load_model(config['model'])
+                print(f"Model {name} loaded successfully")
+            except Exception as e:
+                print(f"Error loading model {name}: {e}")
+                if name == 'financial_sentiment':
+                    print("Using FinBERT as the fallback for financial sentiment analysis")
+                    self.models[name] = self.models['finbert']
+                    self.tokenizers[name] = self.tokenizers['finbert']
+
+    @lru_cache(maxsize=2)  # Cache for 2 models
+    def _load_model(self, model_name):
+        return AutoModelForSequenceClassification.from_pretrained(model_name)
+
+# 4. Method for saving data in the database
+def save_data(ticker, data_type, data):
+    session = Session()
+    try:
+        new_entry = CompanyData(
+            ticker=ticker,
+            data_type=data_type,
+            data=data,
+            date=datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+        )
+        session.add(new_entry)
+        session.commit()
+    except Exception as e:
+        print(f"Error to save data in the database: {e}")
+    finally:
+        session.close()
+# 4.1 Method for getting historical data from the database
+def get_historical_data(ticker):
+    session = Session()
+    try:
+        financials = session.query(CompanyData).filter(
+            CompanyData.ticker == ticker,
+            CompanyData.data_type == 'financials'
+        ).order_by(CompanyData.date.desc()).first()
+
+        news = session.query(CompanyData).filter(
+            CompanyData.ticker == ticker,
+            CompanyData.data_type == 'news'
+        ).order_by(CompanyData.date.desc()).all()
+
+        return {
+            'financials': financials.data if financials else None,
+            'news': [n.data for n in news]
+        }
+    finally:
+        session.close()
+
+# 5. Technical Analysis
+def calculate_rsi(data, window=14):
+    delta = data['Close'].diff()
+    gain = (delta.where(delta > 0, 0)).rolling(window=window).mean()
+    loss = (-delta.where(delta < 0, 0)).rolling(window=window).mean()
+    rs = gain / loss
+    rsi = 100 - (100 / (1 + rs))
+    return rsi.iloc[-1]
+
+# 5.1 Technical Analysis
+def technical_analysis(ticker):
+    try:
+        # Colecting data from Yahoo Finance
+        data = yf.download(ticker, period="6mo", progress=False)
+        
+        # Check if there is enough data
+        if data.empty or data.shape[0] < 50:  # At least 50 days of data
+            print(f"Insuficient data for {ticker}")
+            return None
+            
+        # Remove missing values
+        data = data.dropna()
+        
+        # Calculate SMA50
+        sma_50 = data['Close'].rolling(50).mean().iloc[-1].item()
+        current_price = data['Close'].iloc[-1].item()
+        
+        # Calculate RSI
+        delta = data['Close'].diff().dropna()
+        gain = delta.where(delta > 0, 0.0)
+        loss = -delta.where(delta < 0, 0.0)
+        
+        avg_gain = gain.rolling(14).mean()
+        avg_loss = loss.rolling(14).mean()
+        
+        rs = avg_gain / avg_loss
+        rsi = (100 - (100 / (1 + rs))).iloc[-1].item()
+        
+        return {
+            'price': current_price,
+            'sma_50': sma_50,
+            'price_vs_sma': (current_price / sma_50) - 1,
+            'rsi': rsi if not np.isnan(rsi) else 50,
+            'trend': 'bullish' if current_price > sma_50 else 'bearish'
+        }
+        
+    except Exception as e:
+        print(f"Error in the thecnical analysis: {e}")
+        return None
+
+# 6. Confidence Calculator
+class ConfidenceCalculator:
+    def __init__(self):
+        self.weights = {
+            'sentiment': 0.4,
+            'technical': 0.3,
+            'fundamental': 0.3
+        }
+    # 6.1 Method for calculating the confidence    
+    def calculate(self, sentiment, technical, fundamental):
+        sentiment_score = sentiment['confidence']
+        technical_score = self._normalize_technical(technical)
+        fundamental_score = self._normalize_fundamental(fundamental)
+        
+        weighted_score = (
+            sentiment_score * self.weights['sentiment'] +
+            technical_score * self.weights['technical'] +
+            fundamental_score * self.weights['fundamental']
+        )
+        
+        return {
+            'total_confidence': weighted_score,
+            'components': {
+                'sentiment': sentiment_score,
+                'technical': technical_score,
+                'fundamental': fundamental_score
+            }
+        }
+    # 6.2 Method for normalizing the technical analysis
+    def _normalize_technical(self, tech):
+        if tech is None:
+            return 0.5
+        rsi_score = 1 - abs(tech['rsi'] - 50)/50
+        price_score = np.tanh(tech['price_vs_sma'] * 100)
+        return 0.6*rsi_score + 0.4*price_score
+    # 6.3 Method for normalizing the fundamental analysis
+    def _normalize_fundamental(self, fund):
+        if not fund:
+            return 0.5
+        
+        pe_ratio = fund.get('pe_ratio', 0)
+        sector_pe = fund.get('sector_pe')
+        revenue_growth = fund.get('revenue_growth', 0)
+        
+        # Tratar casos onde sector_pe é None
+        if sector_pe is None:
+            pe_score = 0.5  # Pontuação neutra
+        else:
+            pe_score = 1 if pe_ratio < sector_pe else 0.5
+        
+        growth_score = min(revenue_growth / 20, 1)
+        
+        return 0.5 * pe_score + 0.5 * growth_score
+
+# 7. Analysis Pipeline
+class AnalysisPipeline:
+    def __init__(self, sentiment_threshold=0.6, confidence_threshold=0.7):
+        self.analyst = FinancialAnalyst()
+        self.confidence_calc = ConfidenceCalculator()
+        self.sentiment_threshold = sentiment_threshold  # Novo parâmetro
+        self.confidence_threshold = confidence_threshold  # Novo parâmetro        
+        
+    def set_sentiment_threshold(self, sentiment_threshold):
+        self.sentiment_threshold = sentiment_threshold
+
+    def set_confidence_threshold(self, confidence_threshold):
+        self.confidence_threshold = confidence_threshold
+                
+    # 7.1 Method for getting the fundamental data    
+    def get_fundamental_data(self, ticker):
+        try:
+            company = yf.Ticker(ticker)
+            info = company.info
+            
+            # ensure that the data is valid
+            return {
+                'trailingPE': float(info.get('trailingPE', 0)),
+                'sectorPE': float(info.get('sectorPE', 0)) if info.get('sectorPE') else None,
+                'revenueGrowth': float(info.get('revenueGrowth', 0)),
+                'profitMargins': float(info.get('profitMargins', 0)),
+                'debtToEquity': float(info.get('debtToEquity', 0))
+            }
+        except Exception as e:
+            print(f"Error while performing the fundamental analysis: {e}")
+            return {}
+    # 7.2 Method for getting the news
+    def get_news(self, ticker, api_key=None, fetch_new=True):
+        if fetch_new and api_key:
+            try:
+                newsapi = NewsApiClient(api_key=api_key)
+                from_date = (datetime.now() - timedelta(days=5)).strftime('%Y-%m-%d')
+                news = newsapi.get_everything(q=ticker, from_param=from_date, language='en', sort_by='relevancy')
+                articles = news['articles']
+                save_data(ticker, 'news', articles)
+                return articles
+            except Exception as e:
+                print(f"Error while fetching information online: {e}")
+                return self._get_news_from_db(ticker)
+        else:
+            return self._get_news_from_db(ticker)
+    # 7.3 Method for getting the news from the database
+    def _get_news_from_db(self, ticker):
+        session = Session()
+        try:
+            news_records = session.query(CompanyData).filter(
+                CompanyData.ticker == ticker,
+                CompanyData.data_type == 'news'
+            ).order_by(CompanyData.date.desc()).all()
+            
+            news = []
+            for record in news_records:
+                if isinstance(record.data, list):
+                    news.extend(record.data)
+                elif isinstance(record.data, dict):
+                    news.append(record.data)
+            return news[-5:]  # Últimas 5 notícias
+        except Exception as e:
+            print(f"Error to fetch information from the local database: {e}")
+            return []
+        finally:
+            session.close()
+    # 7.4 Method for analyzing the sentiment
+    def analyze_sentiment(self, news):
+        try:
+            if not news:
+                return {
+                    'sentiment': {'negative': 0.33, 'neutral': 0.33, 'positive': 0.33},
+                    'confidence': 0.5
+                }
+            
+            sentiment_scores = []
+            for item in news:
+                text = f"{item.get('title', '')} {item.get('description', '')}".strip()
+                if not text:
+                    continue
+                
+                inputs = self.analyst.tokenizers['financial_sentiment'](text, return_tensors="pt", truncation=True, max_length=512)
+                outputs = self.analyst.models['financial_sentiment'](**inputs)
+                probabilities = torch.nn.functional.softmax(outputs.logits, dim=-1)
+                sentiment_scores.append(probabilities.detach().numpy()[0])
+            
+            if not sentiment_scores:
+                return {
+                    'sentiment': {'negative': 0.33, 'neutral': 0.33, 'positive': 0.33},
+                    'confidence': 0.5
+                }
+            
+            avg_sentiment = np.mean(sentiment_scores, axis=0)
+            labels = ["negative", "neutral", "positive"]
+            sentiment = {labels[i]: float(avg_sentiment[i]) for i in range(3)}
+            
+            return {
+                'sentiment': sentiment,
+                'confidence': max(sentiment.values())
+            }
+        except Exception as e:
+            print(f"Error while sentimental analysis: {e}")
+            return {
+                'sentiment': {'negative': 0.33, 'neutral': 0.33, 'positive': 0.33},
+                'confidence': 0.5
+            }
+    # 7.5 Method for analyzing the company
+    def analyze_company(self, ticker, news_api_key=None, fetch_new=True):
+        try:
+            # Collecting historical data
+            fundamental = self.get_fundamental_data(ticker)
+            if fetch_new:
+                save_data(ticker, 'financials', fundamental)
+            
+            # Collicting news
+            news = self.get_news(ticker, news_api_key, fetch_new)
+            
+            # Technical analysis
+            technical = technical_analysis(ticker)
+            
+            if not fundamental or not news or technical is None:
+                print(f"Insuficient data for: {ticker}")
+                return None
+            
+            # Sentiment analysis
+            sentiment = self.analyze_sentiment(news)
+            
+            # Confidence calculation
+            confidence = self.confidence_calc.calculate(
+                sentiment, 
+                technical, 
+                self._prepare_fundamental(fundamental)
+            )
+            
+            # Generate recommendation
+            recommendation = self.generate_recommendation(
+                sentiment, technical, fundamental, confidence
+            )
+            
+            return {
+                'recommendation': recommendation,
+                'confidence': confidence,
+                'technical': technical,
+                'fundamental': fundamental,
+                'sentiment': sentiment
+            }
+            
+        except Exception as e:
+            print(f"Erro na análise: {e}")
+            return None
+    # 7.6 Method for preparing the fundamental data
+    def _prepare_fundamental(self, fundamental):
+        return {
+            'pe_ratio': fundamental.get('trailingPE', 0),
+            'sector_pe': fundamental.get('sectorPE'),  # Pode ser None
+            'revenue_growth': fundamental.get('revenueGrowth', 0)
+        }
+    # 7.7 Method for generating the recommendation
+    def generate_recommendation(self, sentiment, technical, fundamental, confidence):
+        pe_ratio = fundamental.get('trailingPE', 0)
+        sector_pe = fundamental.get('sectorPE')
+        
+        # Low confidence condition - NEUTRAL
+        if confidence['total_confidence'] < 0.4:
+            return 'NEUTRAL'
+        
+        # Rules based on fundamental analysis
+        if sector_pe is not None and sector_pe > 0:
+            if pe_ratio < sector_pe * 0.7:
+                return 'BUY'
+            elif pe_ratio > sector_pe * 1.3:
+                return 'SELL'
+        
+        # Rules based on sentiment and confidence
+        if confidence['total_confidence'] > self.confidence_threshold and sentiment['sentiment']['positive'] > self.sentiment_threshold:
+            return 'BUY'
+        
+        # Fallback based on technical analysis
+        if technical and 'trend' in technical:
+            return 'HOLD' if technical['trend'] == 'bullish' else 'SELL'
+        
+        # Final fallback
+        return 'NEUTRAL'
+
+class BacktraderIntegration:
+    def __init__(self, analysis_result=None, strategy_params=None):
+        self.cerebro = bt.Cerebro()
+        self.analysis = analysis_result
+        self.strategy_params = strategy_params or {} 
+        self.setup_environment()
+
+    def setup_environment(self):
+        # Basic configuration of the broker
+        self.cerebro.broker.setcash(100000.0)  # Valor padrão será atualizado
+        self.cerebro.broker.setcommission(commission=0.001)
+        
+        # Custom Strategy
+        if self.analysis:
+            self.cerebro.addstrategy(self.CustomStrategy, analysis=self.analysis, **self.strategy_params)
+        else:
+            self.cerebro.addstrategy(self.CustomStrategy)
+
+    def add_data_feed(self, ticker, start_date, end_date):
+        # Convert datetime to string
+        start_str = start_date.strftime("%Y-%m-%d")
+        end_str = end_date.strftime("%Y-%m-%d")
+
+        # Download data from Yahoo Finance
+        df = yf.download(ticker, start=start_str, end=end_str, progress=False)
+
+        # adjust the columns
+        if isinstance(df.columns, pd.MultiIndex):
+            df.columns = df.columns.droplevel(1)  # remove the multi-index
+
+        # minimum columns expected
+        expected_columns = ["Open", "High", "Low", "Close", "Volume"]
+
+        # Make sure that the columns are correct
+        if not all(col in df.columns for col in expected_columns):
+            raise ValueError(f"Colunas do DataFrame incorretas: {df.columns}")
+
+        # Creates the data feed
+        data = bt.feeds.PandasData(dataname=df)
+        self.cerebro.adddata(data)
+
+    def run_simulation(self, initial_cash, commission):
+        self.cerebro.broker.setcash(initial_cash)
+        self.cerebro.broker.setcommission(commission=commission)
+        print(f'\nStarting Portfolio Value: {self.cerebro.broker.getvalue():.2f}')
+        self.cerebro.run()
+        print(f'Final Portfolio Value: {self.cerebro.broker.getvalue():.2f}')
+        return self.cerebro.broker.getvalue()
+
+    class CustomStrategy(bt.Strategy):
+        params = (
+            ('analysis', None),
+            ('rsi_period', 14),
+            ('rsi_upper', 70),
+            ('rsi_lower', 30),
+            ('sma_short', 50),
+            ('sma_long', 200),
+            ('max_loss_percent', 0.02),
+            ('take_profit_percent', 0.05),
+            ('position_size', 0.1),
+            ('atr_period', 14),
+            ('atr_multiplier', 3),
+            ('sentiment_threshold', 0.6),  # Novo parâmetro
+            ('confidence_threshold', 0.7)  # Novo parâmetro
+        )
+
+        def __init__(self):
+            # Parâmetros agora são acessados via self.params
+            self.recommendation = self.params.analysis['recommendation'] if self.params.analysis else 'HOLD'
+            self.technical_analysis = self.params.analysis['technical'] if self.params.analysis else None
+            self.sentiment_analysis = self.params.analysis['sentiment'] if self.params.analysis else None
+            self.confidence = self.params.analysis['confidence']['total_confidence'] if self.params.analysis else 0.5
+            
+            # Indicadores usando parâmetros dinâmicos
+            self.rsi = bt.indicators.RSI(
+                self.data.close, 
+                period=self.params.rsi_period
+            )
+            
+            self.sma_short = bt.indicators.SMA(
+                self.data.close, 
+                period=self.params.sma_short
+            )
+            
+            self.sma_long = bt.indicators.SMA(
+                self.data.close, 
+                period=self.params.sma_long
+            )
+
+
+            # Technical Indicators
+            self.rsi = bt.indicators.RSI(self.data.close, period=self.p.rsi_period)
+            self.sma_short = bt.indicators.SMA(self.data.close, period=self.p.sma_short)
+            self.sma_long = bt.indicators.SMA(self.data.close, period=self.p.sma_long)
+            
+            # Volatility Indicator
+            self.atr = bt.indicators.ATR(self.data, period=self.p.atr_period)
+            
+            # Trading management
+            self.order = None
+            self.stop_price = None
+            self.take_profit_price = None
+            self.buy_price = None
+            self.entry_date = None
+            
+
+        def log(self, txt, dt=None):
+            dt = dt or self.datas[0].datetime.date(0)
+            print(f'{dt.isoformat()}, {txt}')
+
+        def notify_order(self, order):
+            if order.status in [order.Submitted, order.Accepted]:
+                return
+
+            if order.status in [order.Completed]:
+                if order.isbuy():
+                    self.log(f'BUY EXECUTED, Price: {order.executed.price:.2f}, Cost: {order.executed.value:.2f}, Comm {order.executed.comm:.2f}')
+                    self.buy_price = order.executed.price
+                    self.entry_date = self.datas[0].datetime.date(0)
+                else:
+                    self.log(f'SELL EXECUTED, Price: {order.executed.price:.2f}, Cost: {order.executed.value:.2f}, Comm {order.executed.comm:.2f}')
+                    
+                self.order = None
+
+        def notify_trade(self, trade):
+            if not trade.isclosed:
+                return
+            
+            self.log(f'TRADE PROFIT, GROSS: {trade.pnl:.2f}, NET: {trade.pnlcomm:.2f}')
+
+        def calculate_position_size(self):
+            portfolio_value = self.broker.getvalue()
+            return int((portfolio_value * self.p.position_size) / self.data.close[0])
+
+        def next(self):
+            # Prevent multiple orders
+            if self.order:
+                return
+
+            current_price = self.data.close[0]
+            portfolio_value = self.broker.getvalue()
+            
+            # Usar parâmetros dinâmicos nas regras
+            stop_loss = current_price * (1 - self.params.max_loss_percent)
+            take_profit = current_price * (1 + self.params.take_profit_percent)
+ 
+            # Analyze prior analysis for additional confirmation
+            analysis_confirmation = self._analyze_prior_research()
+
+            # No open position - look for entry
+            if not self.position:
+                # Enhanced entry conditions
+                # Condições com parâmetros ajustáveis
+                entry_conditions = (
+                    current_price > self.sma_long[0] and
+                    self.rsi[0] < self.params.rsi_lower and
+                    bool(self.params.analysis['confidence']['total_confidence'] > self.p.confidence_threshold)
+                )
+
+                if entry_conditions:
+                    # Calculate position size
+                    size = self.calculate_position_size()
+                    
+                    # Place buy order
+                    self.order = self.buy(size=size)
+                    
+                    # Calculate stop loss and take profit
+                    stop_loss = current_price * (1 - self.p.max_loss_percent)
+                    take_profit = current_price * (1 + self.p.take_profit_percent)
+                    
+                    # Alternative stop loss using ATR for volatility
+                    atr_stop = current_price - (self.atr[0] * self.p.atr_multiplier)
+                    self.stop_price = max(stop_loss, atr_stop)
+                    self.take_profit_price = take_profit
+
+            # Manage existing position
+            else:
+                # Exit conditions
+                exit_conditions = (
+                    current_price < self.stop_price or  # Stop loss triggered
+                    current_price > self.take_profit_price or  # Take profit reached
+                    self.rsi[0] > self.p.rsi_upper or  # Overbought condition
+                    current_price < self.sma_short[0] or  # Trend change
+                    not analysis_confirmation  # Loss of analysis confirmation
+                )
+
+                if exit_conditions:
+                    self.close()  # Close entire position
+                    self.stop_price = None
+                    self.take_profit_price = None
+
+        def _analyze_prior_research(self):
+            # Integrate multiple analysis aspects
+            if not self.p.analysis:
+                return True
+
+            # Sentiment analysis check
+            sentiment_positive = (
+                self.sentiment_analysis and 
+                self.sentiment_analysis['sentiment']['positive'] > self.p.sentiment_threshold
+            )
+
+            # Technical analysis check
+            technical_bullish = (
+                self.technical_analysis and 
+                self.technical_analysis['trend'] == 'bullish'
+            )
+
+            # Confidence check
+            high_confidence = bool(self.confidence > self.p.confidence_threshold)
+
+            # Combine conditions
+            return sentiment_positive and technical_bullish and high_confidence
+
+        def stop(self):
+            # Final report when backtest completes
+            self.log('Final Portfolio Value: %.2f' % self.broker.getvalue())
+
+# 8. Main
+if __name__ == "__main__":
+    pipeline = AnalysisPipeline()
+    
+    print("\n=== Analysis of Stock-Market ===")
+    
+    # 1. Requesting the company ticker
+    ticker = input("Type the company ticker (ex: AAPL): ").strip().upper()
+    
+    # 2. Requesting if the user wants to fetch new data
+    while True:
+        fetch_new = input("Would you like to have new data from internet? (y/n): ").lower()
+        if fetch_new in ['y', 'n', 'yes', 'no', 'no']:
+            fetch_new_bool = fetch_new in ['y', 'no']
+            break
+        print("Not a valid option! Type y or n")
+    
+    initial_investment = float(input("Inicial Investment (USD): "))
+    years_back = int(input("Historical Period (years): "))
+    commission = float(input("Commission per trade: "))
+    
+    # 3. API Key for NewsAPI
+    news_api_key = '85bfdbb4f83f4b148cd219196b4b6447'
+    
+    # 4. Running the analysis
+    print(f"\nRunning the analysis with Machine Learning {ticker}...")
+    result = pipeline.analyze_company(
+        ticker=ticker,
+        news_api_key=news_api_key if news_api_key else None,
+        fetch_new=fetch_new_bool
+    )
+    
+    # 5. Showing the results
+    if result:
+        
+        # Running the simulation with Backtrader
+        end_date = datetime.now()
+        start_date = end_date - timedelta(days=years_back*365)
+        
+        bt_integration = BacktraderIntegration(result)
+        bt_integration.add_data_feed(ticker, start_date, end_date)
+        final_value = bt_integration.run_simulation(initial_investment, commission)
+        
+        print("\n=== Analysis Result ===")
+        print(f"Recommendation: {result['recommendation']}")
+        print(f"Confidence: {result['confidence']['total_confidence']:.2%}")
+        print(f"Return of the Simulation: {(final_value/initial_investment-1)*100:.2f}%")
+        print("\nDetails:")
+        print(f"1. Sentiment: {json.dumps(result['sentiment']['sentiment'], indent=2)}")
+        print(f"2. Technical Analysis: RSI {result['technical']['rsi']:.1f}, Price vs SMA50: {result['technical']['price_vs_sma']:.2%}")
+        print(f"3. Fundamental: P/E {result['fundamental'].get('trailingPE', 'N/A')} vs Sctor {result['fundamental'].get('sectorPE', 'N/A')}")
+        print(f"4. Confidence Components: {json.dumps(result['confidence']['components'], indent=2)}")
+    else:
+        print("\nIt was not possible to run the analysis, please check:")
+        print("- Internet connection")
+        print("- Ticker value")
+        print("- Historical data availability")