Release 0.002

analysis/fundamental.py

@@ -0,0 +1,15 @@
+# analysis/fundamental.py
+from data.api_client import YahooFinanceClient
+
+class FundamentalAnalyzer:
+    @staticmethod
+    def analyze(ticker):
+        info = YahooFinanceClient.get_company_info(ticker)
+        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)),
+            'shortName': info.get('shortName')
+        }

analysis/sentiment.py

@@ -0,0 +1,66 @@
+import torch
+import numpy as np
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+from scipy.stats import zscore
+
+class SentimentAnalyzer:
+    def __init__(self):
+        self.models = {
+            'finbert': AutoModelForSequenceClassification.from_pretrained("yiyanghkust/finbert-tone"),
+            'financial_sentiment': AutoModelForSequenceClassification.from_pretrained("ahmedrachid/FinancialBERT-Sentiment-Analysis")
+        }
+        self.tokenizers = {
+            'finbert': AutoTokenizer.from_pretrained("yiyanghkust/finbert-tone"),
+            'financial_sentiment': AutoTokenizer.from_pretrained("ahmedrachid/FinancialBERT-Sentiment-Analysis")
+        }
+        self.max_length = 512  # Limite do modelo
+
+    def chunk_text(self, text, tokenizer):
+        tokens = tokenizer.encode(text, truncation=False)
+        return [tokens[i:i+self.max_length] for i in range(0, len(tokens), self.max_length)]
+    
+    def preprocess_text(self, item):
+        title = str(item.get('title', '')).strip()  
+        content = str(item.get('content', '')).strip()
+        text = f"{title} {content}".strip()
+        return text if text else None
+
+
+    def analyze(self, news):
+        if not news:
+            return {'negative': 0.33, 'neutral': 0.33, 'positive': 0.33}
+
+        sentiment_scores = []
+
+        for item in news:
+            if not isinstance(item, dict):
+                continue
+
+            text = self.preprocess_text(item)
+            if not text:
+                continue
+            
+            tokenizer = self.tokenizers['financial_sentiment']
+            model = self.models['financial_sentiment']
+            
+            tokenized_chunks = self.chunk_text(text, tokenizer)
+            chunk_scores = []
+            
+            for chunk in tokenized_chunks:
+                inputs = tokenizer.decode(chunk, skip_special_tokens=True)
+                inputs = tokenizer(inputs, return_tensors="pt", truncation=True, max_length=self.max_length)
+                outputs = model(**inputs)
+                probabilities = torch.nn.functional.softmax(outputs.logits, dim=-1)
+                chunk_scores.append(probabilities.detach().numpy()[0])
+            
+            if chunk_scores:
+                sentiment_scores.append(np.mean(chunk_scores, axis=0))
+
+        if not sentiment_scores:
+            return {'negative': 0.33, 'neutral': 0.33, 'positive': 0.33}
+
+        # Filtro de outliers
+        filtered_scores = [s for s in sentiment_scores if np.abs(zscore(s)).max() < 2]
+        avg_sentiment = np.mean(filtered_scores, axis=0) if filtered_scores else np.mean(sentiment_scores, axis=0)
+
+        return {'negative': float(avg_sentiment[0]), 'neutral': float(avg_sentiment[1]), 'positive': float(avg_sentiment[2])}

analysis/technical.py

@@ -0,0 +1,33 @@
+# analysis/technical.py
+import numpy as np
+from data.api_client import YahooFinanceClient
+
+class TechnicalAnalyzer:
+    @staticmethod
+    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
+        return 100 - (100 / (1 + rs))
+
+    @staticmethod
+    def calculate_sma(data, window):
+        return data['Close'].rolling(window=window).mean()
+
+    def analyze(self, ticker):
+        data = YahooFinanceClient.download_data(ticker, period='1y')
+        if data.empty or data.shape[0] < 50:
+            return None
+
+        sma_50 = self.calculate_sma(data, 50).iloc[-1].item()
+        current_price = data['Close'].iloc[-1].item()
+        rsi = self.calculate_rsi(data).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'
+        }

app.py

@@ -1,7 +1,9 @@
+# app.py
 import gradio as gr
 from datetime import datetime, timedelta
-import stocks as st
-
+from stocks import AnalysisPipeline, BacktraderIntegration
+import matplotlib.pyplot as plt
+import matplotlib.dates as mdates
 
 class GradioInterface:
     def __init__(self, pipeline):
@@ -12,20 +14,19 @@ class GradioInterface:
             '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,
+            'max_loss_percent': 5,
+            'take_profit_percent': 5,
+            'position_size': 10,
+            'atr_period': 7,
             'atr_multiplier': 3,
-            'confidence_threshold' : 0.7,
-            'sentiment_threshold' : 0.5
+            'confidence_threshold': 35,
+            'sentiment_threshold': 25
         }
-        
+
     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("### Parameters for Trading Strategy")
                     inputs = {}
                     inputs['rsi_period'] = gr.Number(value=14, label="RSI Period", minimum=1)
@@ -33,68 +34,41 @@ class GradioInterface:
                     inputs['rsi_lower'] = gr.Number(value=30, label="RSI Lower Limit", minimum=0, maximum=100)
                     inputs['sma_short'] = gr.Number(value=50, label="SMA Short (period)")
                     inputs['sma_long'] = gr.Number(value=200, label="SMA Long (period)")
-                    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="Position Size(%)")
+                    inputs['max_loss_percent'] = gr.Slider(1, 100, value=5, step=5, label="Stop Loss (%)")
+                    inputs['take_profit_percent'] = gr.Slider(1, 100, value=5, step=5, label="Take Profit (%)")
+                    inputs['position_size'] = gr.Slider(1, 100, value=5, step=5, label="Position Size(%)")
                     inputs['atr_period'] = gr.Number(value=14, label="ATR Period")
                     inputs['atr_multiplier'] = gr.Number(value=3, label="ATR Multiplier")
-                    inputs['confidence_threshold'] = gr.Number(value=70, label="Confidence Threshold(%)", minimum=0, maximum=100)
-                    inputs['sentiment_threshold'] = gr.Number(value=50, label="Sentiment Threshold(%)", minimum=0, maximum=100)
-                    save_btn = gr.Button("Save Configuration")                    
-                    # Adicionando a explicação em Markdown
+                    inputs['confidence_threshold'] = gr.Slider(1, 100, value=30, step=5, label="Confidence Threshold(%)")
+                    inputs['sentiment_threshold'] = gr.Slider(1, 100, value=25, step=5, label="Sentiment Threshold(%)")
+                    save_btn = gr.Button("Save Configuration")
+
                     gr.Markdown("""
                         ## 📊 Explanation of Trading Strategy Parameters
-
                         These parameters configure technical indicators to assist in buy and sell decisions for assets.
-
                         ### **📉 RSI (Relative Strength Index)**
-                        The RSI is used to measure the strength of an asset's movement.
-
-                        - **`rsi_period` (14)** → Number of periods to calculate the RSI (default: 14).
-                        - **`rsi_upper` (70)** → If the RSI is greater than this value, it may indicate overbought conditions (sell signal).
-                        - **`rsi_lower` (30)** → If the RSI is less than this value, it may indicate oversold conditions (buy signal).
-
-                        ---
-
+                        - **`rsi_period` (14)** → Number of periods to calculate the RSI.
+                        - **`rsi_upper` (70)** → Overbought conditions (sell signal).
+                        - **`rsi_lower` (30)** → Oversold conditions (buy signal).
                         ### **📈 Simple Moving Averages (SMA)**
-                        Indicators that smooth prices over time.
-
-                        - **`sma_short` (50)** → Short-term moving average, used to capture short-term trends.
-                        - **`sma_long` (200)** → Long-term moving average, used to capture long-term trends.
-
-                        ---
-
+                        - **`sma_short` (50)** → Short-term moving average.
+                        - **`sma_long` (200)** → Long-term moving average.
                         ### **📉 Risk Management**
-
-                        - **`max_loss_percent` (0.02)** → Stop Loss (loss limit). If the price falls more than 2%, the position is closed.
-                        - **`take_profit_percent` (0.05)** → Take Profit (profit limit). If the price rises 5%, the position is closed.
-                        - **`position_size` (0.1)** → Proportion of total capital to be used in a trade (10% of the balance).
-
-                        ---
-
+                        - **`max_loss_percent` (0.02)** → Stop Loss (loss limit).
+                        - **`take_profit_percent` (0.05)** → Take Profit (profit limit).
+                        - **`position_size` (0.1)** → Proportion of total capital to be used in a trade.
                         ### **📊 ATR (Average True Range) - Volatility**
-                        The ATR is used to measure the volatility of an asset.
-
                         - **`atr_period` (14)** → Number of periods to calculate the ATR.
-                        - **`atr_multiplier` (3)** → ATR multiplier, often used to define dynamic stop loss.
-
-                        ---
-
-                        ## **🚀 How Do These Parameters Affect the Strategy?**
-
-                        - **If `rsi_lower` is lower (e.g., 20), the strategy will buy in more oversold regions.**
-                        - **If `max_loss_percent` is too small, it may close trades prematurely.**
-                        - **If `atr_multiplier` is larger, the stop loss will be wider, allowing for more volatility.**
-                        - **If `sma_short` and `sma_long` are far apart, entries will be more conservative.**
+                        - **`atr_multiplier` (3)** → ATR multiplier for dynamic stop loss.
                     """)
-  
+
             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',
@@ -102,57 +76,54 @@ class GradioInterface:
             '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)
+        print("Updated parameters:", self.strategy_params)
         return gr.Info("Settings saved!")
-    
+
     def create_main_interface(self):
         with gr.Blocks() as main_interface:
             with gr.Row():
                 with gr.Column():
                     ticker_input = gr.Text(label="Ticker (ex: VALE)", placeholder="Insert a stock ticker based on Yahoo Finance")
-                    api_key_input = gr.Textbox(label="API Key (required)", placeholder="Insert your API Key https://newsapi.org/")
                     fetch_new = gr.Dropdown([True, False], label="Check last news information online (Requires API)?", value=False)
-                    initial_investment = gr.Number(10000, label="Initial Investiment (USD)")
+                    api_key_input = gr.Textbox(label="API Key", placeholder="Insert your API Key https://newsapi.org/")
+                    initial_investment = gr.Number(10000, label="Initial Investment (USD)")
                     years_back = gr.Number(5, label="Historical Data (years back)")
-                    commission = gr.Number(0.001, label="Trade Commission (%)")
+                    commission = gr.Number(2, label="Trade Commission (%)", minimum=0, maximum=100)
                     run_btn = gr.Button("Execute Analysis")
                 with gr.Column():
                     plot_output = gr.Plot()
             with gr.Row():
-                # Adicionar uma saída para os resultados
                 output_md = gr.Markdown()
             with gr.Row():
-                # Adicionar uma saída para os resultados
                 output_ops = 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, output_ops, 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)
-        
+        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 "Something wrong is not right :)", None
-            
+            return "Something went wrong. Please check your inputs.", None, None
+
         # Configurar simulação
         end_date = datetime.now()
-        start_date = end_date - timedelta(days=int(years_back*365))
-        
+        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']),
@@ -160,27 +131,18 @@ class GradioInterface:
             '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']),
+            'max_loss_percent': float(self.strategy_params['max_loss_percent'])/100,
+            'take_profit_percent': float(self.strategy_params['take_profit_percent'])/100,
+            'position_size': float(self.strategy_params['position_size'])/100,
             '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
+            '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="Preparing simulation...")
-        
         # Executar simulação
-        bt_integration = st.BacktraderIntegration(analysis_result=result,strategy_params=custom_strategy_params)
+        bt_integration = BacktraderIntegration(analysis_result=result, strategy_params=custom_strategy_params)
         bt_integration.add_data_feed(ticker, start_date, end_date)
-            
-        progress(0.6, desc="Executing simulation...")
-           
         final_value, operation_logs = bt_integration.run_simulation(
             initial_cash=initial_investment,
             commission=commission
@@ -204,23 +166,12 @@ class GradioInterface:
                 date = parts[0].strip()
                 details = ", ".join(parts[1:])
                 formatted_logs.append(f"- 📈 **Result** ({date}): {details}")
-            elif "Final Portfolio Value" in log:
-                continue
-                
-        
+
         # Adicionar seção de logs na saída
         output_ops = "### Log :\n\n" + "\n".join(formatted_logs)
-                
-        progress(0.9, desc="Generating final result...")
-            
-        # Extrair os valores do JSON de sentimento
-        sentiment = result['sentiment']['sentiment']
-        negative_sentiment = sentiment.get('negative', 0.0)
-        neutral_sentiment = sentiment.get('neutral', 0.0)
-        positive_sentiment = sentiment.get('positive', 0.0)
 
-        
         # Gerar saída formatada em Markdown
+        sentiment = result['sentiment']
         output = f"""
         ## Recommendation: {result['recommendation']}
         
@@ -228,58 +179,43 @@ class GradioInterface:
         
         ## Simulation Results:
         - **Initial Investment**: ${initial_investment:.2f}
-        - **Simulation Summary**: {(final_value/initial_investment-1)*100:.2f}%  
+        - **Simulation Summary**: {(final_value / initial_investment - 1) * 100:.2f}%  
         - **Final Portfolio Value**: ${final_value:.2f}
         
         ### Details:
         
-        - **Negative Sentiment**: {negative_sentiment:.2%}  
-        - **Neutral Sentiment**: {neutral_sentiment:.2%}  
-        - **Positive Sentiment**: {positive_sentiment:.2%}  
+        - **Negative Sentiment**: {sentiment.get('negative', 0.0):.2%}  
+        - **Neutral Sentiment**: {sentiment.get('neutral', 0.0):.2%}  
+        - **Positive Sentiment**: {sentiment.get('positive', 0.0):.2%}  
         
         - **RSI**: {result['technical']['rsi']:.1f}  
         - **Price vs SMA50**: {result['technical']['price_vs_sma']:.2%}  
         - **P/E Ratio**: {result['fundamental'].get('trailingPE', 'N/A')}  
         """
-        
-        # Gerar gráfico simples (exemplo)
+
+        # Gerar gráfico simples
         plot = self.generate_simple_plot(bt_integration)
-        
+
         return output, output_ops, plot
 
-    # Função para gerar um gráfico simples
     def generate_simple_plot(self, bt_integration):
-        import matplotlib.pyplot as plt
-        import matplotlib.dates as mdates
-
         plt.figure(figsize=(12, 6))
-        
-        # Get data feed from Backtrader
         datafeed = bt_integration.cerebro.datas[0]
-        
-        # Extract dates and closing prices
         dates = [datetime.fromordinal(int(date)) for date in datafeed.datetime.array]
         closes = datafeed.close.array
-        
-        # Plot
         plt.plot(dates, closes, label='Close Price', linewidth=1.5)
-        
-        # Format dates
         plt.gca().xaxis.set_major_formatter(mdates.DateFormatter('%Y-%m'))
         plt.gca().xaxis.set_major_locator(mdates.MonthLocator(interval=3))
-        plt.gcf().autofmt_xdate()  # Rotate dates
-        
-        # Add labels and grid
+        plt.gcf().autofmt_xdate()
         plt.title("Historical Price Data")
-        plt.xlabel("Data")
+        plt.xlabel("Date")
         plt.ylabel("Price (USD)")
         plt.legend()
         plt.grid(True, alpha=0.3)
-        
         return plt.gcf()
-# Configuração da interface completa
-pipeline = st.AnalysisPipeline()
 
+# Configuração da interface completa
+pipeline = AnalysisPipeline()
 interface = GradioInterface(pipeline)
 
 demo = gr.TabbedInterface(
@@ -289,5 +225,4 @@ demo = gr.TabbedInterface(
 )
 
 if __name__ == "__main__":
-    #demo.launch(share=True)
     demo.launch(share=True)

data/api_client.py

@@ -0,0 +1,26 @@
+# data/api_client.py
+import yfinance as yf
+from newsapi import NewsApiClient
+from datetime import datetime, timedelta
+
+class YahooFinanceClient:
+    @staticmethod
+    def download_data(ticker, start_str=None, end_str=None, period="6mo"):
+        if period:
+            return yf.download(ticker, period=period, progress=False)
+        else:
+            return yf.download(ticker, start=start_str, end=end_str, progress=False)
+
+    @staticmethod
+    def get_company_info(ticker):
+        company = yf.Ticker(ticker)
+        return company.info
+
+class NewsAPIClient:
+    def __init__(self, api_key):
+        self.client = NewsApiClient(api_key=api_key)
+
+    def get_news(self, shortName, days_back=15):
+        from_date = (datetime.now() - timedelta(days=days_back)).strftime('%Y-%m-%d')
+        return self.client.get_everything(q=shortName, from_param=from_date, language='en', sort_by='relevancy', page_size=20)['articles']
+

data/database.py

@@ -0,0 +1,57 @@
+# data/database.py
+from sqlalchemy import create_engine, Column, Integer, String, JSON
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+from datetime import datetime
+
+Base = declarative_base()
+
+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)
+
+class DatabaseManager:
+    def __init__(self, db_url='sqlite:///financial_data.db'):
+        self.engine = create_engine(db_url)
+        self.Session = sessionmaker(bind=self.engine)
+        Base.metadata.create_all(self.engine)
+
+    def save_data(self, ticker, data_type, data):
+        session = self.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 saving data: {e}")
+        finally:
+            session.close()
+
+    def get_historical_data(self, ticker):
+        session = self.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()

stocks.py

@@ -1,158 +1,26 @@
-import yfinance as yf
-import pandas as pd
+# stocks.py
+from datetime import datetime, timedelta
 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
-
+# Importações dos novos módulos
+from data.database import DatabaseManager
+from data.api_client import NewsAPIClient
+from analysis.technical import TechnicalAnalyzer
+from analysis.fundamental import FundamentalAnalyzer
+from analysis.sentiment import SentimentAnalyzer
+from strategies.backtrader import BacktraderIntegration
 
-# 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)
+# Database configuration
+db_manager = DatabaseManager()
 
-# 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()
+# Analyzers configuration
+technical_analyzer = TechnicalAnalyzer()
+fundamental_analyzer = FundamentalAnalyzer()
+sentiment_analyzer = SentimentAnalyzer()
 
-        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
+# Confidence calculator
 class ConfidenceCalculator:
     def __init__(self):
         self.weights = {
@@ -160,18 +28,18 @@ class ConfidenceCalculator:
             'technical': 0.3,
             'fundamental': 0.3
         }
-    # 6.1 Method for calculating the confidence    
+
     def calculate(self, sentiment, technical, fundamental):
-        sentiment_score = sentiment['confidence']
+        sentiment_score = self._normalie_sentiment(sentiment)
         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': {
@@ -180,172 +48,104 @@ class ConfidenceCalculator:
                 'fundamental': fundamental_score
             }
         }
-    # 6.2 Method for normalizing the technical analysis
+
+    def _normalie_sentiment(self, sentiment):
+        """
+        Normaliza o sentimento em um único score de confiança.
+        
+        Parâmetros:
+            sentiment (dict): {'negative': float, 'neutral': float, 'positive': float}
+
+        Retorno:
+            float: score normalizado entre 0 e 1.
+        """
+        # Definição dos pesos para cada categoria
+        weight_positive = 1.0   # Sentimento positivo contribui mais
+        weight_neutral = 0.5    # Neutro tem impacto médio
+        weight_negative = 0.0   # Negativo reduz a confiança
+
+        # Cálculo do score ponderado
+        sentiment_score = (
+            sentiment['positive'] * weight_positive +
+            sentiment['neutral'] * weight_neutral +
+            sentiment['negative'] * weight_negative
+        )
+
+        # Garantindo que o score fique entre 0 e 1
+        return max(0.0, min(1.0, sentiment_score))
+
+
     def _normalize_technical(self, tech):
         if tech is None:
             return 0.5
-        rsi_score = 1 - abs(tech['rsi'] - 50)/50
+        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
+        return 0.6 * rsi_score + 0.4 * price_score
+
     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
+            pe_score = 0.5
         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
+# 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        
-        
+        self.sentiment_threshold = sentiment_threshold
+        self.confidence_threshold = confidence_threshold
+
     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)
+            # fundamental analysis
+            fundamental = fundamental_analyzer.analyze(ticker)
             
-            # Technical analysis
-            technical = technical_analysis(ticker)
+            shortName = fundamental['shortName'].split()[0]
             
+            if fetch_new:
+                db_manager.save_data(ticker, 'financials', fundamental)
+
+            # collecting last news
+            news = self._get_news(shortName, ticker, news_api_key, fetch_new)
+
+            # technical analysis
+            technical = technical_analyzer.analyze(ticker)
+
             if not fundamental or not news or technical is None:
-                print(f"Insuficient data for: {ticker}")
+                print(f"Insufficient data for: {ticker}")
                 return None
-            
+
             # Sentiment analysis
-            sentiment = self.analyze_sentiment(news)
-            
+            sentiment = sentiment_analyzer.analyze(news)
+
             # Confidence calculation
             confidence = self.confidence_calc.calculate(
-                sentiment, 
-                technical, 
+                sentiment,
+                technical,
                 self._prepare_fundamental(fundamental)
             )
-            
-            # Generate recommendation
+
+            # Recommendation generation
             recommendation = self.generate_recommendation(
                 sentiment, technical, fundamental, confidence
             )
-            
+
             return {
                 'recommendation': recommendation,
                 'confidence': confidence,
@@ -353,326 +153,96 @@ class AnalysisPipeline:
                 'fundamental': fundamental,
                 'sentiment': sentiment
             }
-            
+
         except Exception as e:
-            print(f"Erro na análise: {e}")
+            print(f"Error in analysis: {e}")
             return None
-    # 7.6 Method for preparing the fundamental data
+
+    def _get_news(self, shortName, ticker, api_key, fetch_new):
+        if fetch_new and api_key:
+            try:
+                news_client = NewsAPIClient(api_key)
+                articles = news_client.get_news(shortName)
+                
+                # Flatten the list of articles
+                db_manager.save_data(ticker, 'news', articles)
+                return articles
+            except Exception as e:
+                print(f"Error fetching news: {e}")
+                return db_manager.get_historical_data(ticker)['news']
+        else:
+            return db_manager.get_historical_data(ticker)['news']
+
     def _prepare_fundamental(self, fundamental):
         return {
             'pe_ratio': fundamental.get('trailingPE', 0),
-            'sector_pe': fundamental.get('sectorPE'),  # Pode ser None
+            'sector_pe': fundamental.get('sectorPE'),
             '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:
+
+        if confidence['total_confidence'] > self.confidence_threshold and 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)
-        
-    # 7.8 Method for running the simulation
-    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()
-        
-        # Coletar logs de todas as estratégias
-        operation_logs = []
-        for strategy in self.cerebro.runstrats:
-            operation_logs.extend(strategy[0].operation_logs)
-                        
-        print(f'Final Portfolio Value: {self.cerebro.broker.getvalue():.2f}')
-        return self.cerebro.broker.getvalue(), operation_logs  # Retorna ambos valores
-    # 7.9 Custom Strategy
-    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.operation_logs = []  # Lista para armazenar os logs
-            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)
-            log_entry = f'{dt.isoformat()}, {txt}'
-            self.operation_logs.append(log_entry)  # Armazena na lista
-            print(log_entry)  # Mantém o print original
-
-        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'
-            )
+        return 'NEUTRAL'
 
-            # Confidence check
-            high_confidence = bool(self.confidence > self.p.confidence_threshold)
+# Main function
+if __name__ == "__main__":
+    pipeline = AnalysisPipeline()
 
-            # Combine conditions
-            return sentiment_positive and technical_bullish and high_confidence
+    print("\n=== Stock Market Analysis ===")
+    ticker = input("Enter the company ticker (e.g., AAPL): ").strip().upper()
 
-        def stop(self):
-            # Final report when backtest completes
-            self.log('Final Portfolio Value: %.2f' % self.broker.getvalue())
+    fetch_new = input("Fetch new data from the internet? (y/n): ").lower()
+    fetch_new_bool = fetch_new in ['y', 'yes']
 
-# 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): "))
+    initial_investment = float(input("Initial Investment (USD): "))
     years_back = int(input("Historical Period (years): "))
     commission = float(input("Commission per trade: "))
-    
-    # 3. API Key for NewsAPI
-    news_api_key = 'INSIRA SUA CHAVE AQUI'
-    
-    # 4. Running the analysis
-    print(f"\nRunning the analysis with Machine Learning {ticker}...")
+
+    news_api_key = 'YOUR_NEWSAPI_KEY_HERE'
+
+    print(f"\nRunning analysis for {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)
-        
+        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(f"Simulation Return: {(final_value / initial_investment - 1) * 100:.2f}%")
         print("\nDetails:")
-        print(f"1. Sentiment: {json.dumps(result['sentiment']['sentiment'], indent=2)}")
+        print(f"1. Sentiment: {json.dumps(result['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"3. Fundamental: P/E {result['fundamental'].get('trailingPE', 'N/A')} vs Sector {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("\nUnable to complete analysis. Please check:")
         print("- Internet connection")
-        print("- Ticker value")
-        print("- Historical data availability")
+        print("- Ticker symbol")
+        print("- Availability of historical data")

strategies/backtrader.py

@@ -0,0 +1,238 @@
+# strategies/backtrader.py
+import backtrader as bt
+import sys
+import os
+import pandas as pd
+
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+from data.api_client import YahooFinanceClient
+
+
+class Logger:
+    def __init__(self):
+        self.logs = []
+    
+    def add_log(self, log_entry):
+        self.logs.append(log_entry)
+    
+    def get_logs(self):
+        return self.logs.copy()  # Return a copy to prevent direct modification
+
+class CustomStrategy(bt.Strategy):
+    params = (
+        ('analysis', None),
+        ('logger', 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.logger = self.params.logger
+        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)
+        log_entry = f'{dt.isoformat()}, {txt}'
+        self.logger.add_log(log_entry)  # Store in shared logger
+        print(log_entry)
+        
+    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]
+        
+        # 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['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())
+
+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.logger = Logger()  # Create shared logger instance
+        self.setup_environment()
+
+    def setup_environment(self):
+        self.cerebro.broker.setcash(100000.0)
+        self.cerebro.broker.setcommission(commission=0.001)
+        self.cerebro.addstrategy(CustomStrategy, analysis=self.analysis, logger=self.logger, **self.strategy_params)
+
+    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 = YahooFinanceClient.download_data(ticker, start_str, end_str, period=None)
+
+                
+        if not isinstance(df, pd.DataFrame):
+            raise TypeError(f"Esperado pandas.DataFrame, mas recebeu {type(df)}")
+
+        # 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}")        
+        
+        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/100)
+        self.cerebro.run()
+        
+        logs = self.logger.get_logs()
+        
+        return self.cerebro.broker.getvalue(), logs

test.py

@@ -0,0 +1,39 @@
+import hashlib
+import random
+import time
+
+# Dummy lightweight LLM model function
+def lightweight_llm(seed, difficulty_prefix):
+    """
+    Simulate the LLM finding a candidate hash starting with a given pattern.
+    The seed is used to generate a random number and the difficulty_prefix is what we aim for.
+    """
+    random.seed(seed + time.time())
+    candidate = f"{random.getrandbits(256):064x}"
+    if candidate.startswith(difficulty_prefix):
+        return candidate
+    return None
+
+def mine_block(block_data, difficulty_prefix='000'):
+    """
+    Simplified mining function using a lightweight LLM model.
+    """
+    seed = random.randint(0, 1 << 32)
+    while True:
+        candidate_hash = lightweight_llm(seed, difficulty_prefix)
+        if candidate_hash:
+            # Incorporate block data and candidate hash
+            block_header = f"{block_data}{candidate_hash}"
+            final_hash = hashlib.sha256(block_header.encode()).hexdigest()
+            if final_hash.startswith(difficulty_prefix):
+                print(f"Block mined with candidate hash: {candidate_hash}")
+                return final_hash
+        # Optionally update the seed to vary the input
+        seed = random.randint(0, 1 << 32)
+
+# Example block data and mining process
+if __name__ == '__main__':
+    block_data = "previous_hash:0000000000000000000, transactions: [...]"
+    print("Starting mining process...")
+    new_block_hash = mine_block(block_data, difficulty_prefix='0000')
+    print(f"New block hash: {new_block_hash}")