bbstrader 0.3.1__py3-none-any.whl → 0.3.3__py3-none-any.whl

bbstrader/models/nlp.py

@@ -2,15 +2,17 @@ import contextlib
 import os
 import re
 import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
 from datetime import datetime
 from typing import Dict, List, Tuple
 
 import dash
+import en_core_web_sm
 import matplotlib.pyplot as plt
 import nltk
 import pandas as pd
 import plotly.express as px
-import en_core_web_sm
+from bbstrader.core.data import FinancialNews
 from dash import dcc, html
 from dash.dependencies import Input, Output
 from nltk.corpus import stopwords
@@ -18,12 +20,10 @@ from nltk.tokenize import word_tokenize
 from textblob import TextBlob
 from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer
 
-from bbstrader.core.data import FinancialNews
-
-
 __all__ = [
     "TopicModeler",
     "SentimentAnalyzer",
+    "LEXICON",
     "EQUITY_LEXICON",
     "FOREX_LEXICON",
     "COMMODITIES_LEXICON",
@@ -331,6 +331,17 @@ FINANCIAL_LEXICON = {
     **BONDS_LEXICON,
 }
 
+LEXICON = {
+    "stock": EQUITY_LEXICON,
+    "etf": EQUITY_LEXICON,
+    "future": FINANCIAL_LEXICON,
+    "forex": FOREX_LEXICON,
+    "crypto": CRYPTO_LEXICON,
+    "index": EQUITY_LEXICON,
+    "bond": BONDS_LEXICON,
+    "commodity": COMMODITIES_LEXICON,
+}
+
 
 class TopicModeler(object):
     def __init__(self):
@@ -345,7 +356,7 @@ class TopicModeler(object):
                 "SpaCy model 'en_core_web_sm' not found. "
                 "Please install it using 'python -m spacy download en_core_web_sm'."
             )
-        
+
     def preprocess_texts(self, texts: list[str]):
         def clean_doc(Doc):
             doc = []
@@ -379,11 +390,6 @@ class SentimentAnalyzer(object):
     analysis using VADER (SentimentIntensityAnalyzer) and optional TextBlob
     for enhanced polarity scoring.
 
-    Attributes:
-        nlp (spacy.Language): A SpaCy NLP pipeline for tokenization and lemmatization,
-                               with Named Entity Recognition (NER) disabled.
-        analyzer (SentimentIntensityAnalyzer): An instance of VADER's sentiment analyzer
-                                               for financial sentiment scoring.
     """
 
     def __init__(self):
@@ -395,8 +401,6 @@ class SentimentAnalyzer(object):
         - Loads the `en_core_web_sm` SpaCy model with Named Entity Recognition (NER) disabled.
         - Initializes VADER's SentimentIntensityAnalyzer for sentiment scoring.
 
-        Args:
-            use_spacy (bool): If True, uses SpaCy for lemmatization. Defaults to False.
         """
         nltk.download("punkt", quiet=True)
         nltk.download("stopwords", quiet=True)
@@ -431,7 +435,9 @@ class SentimentAnalyzer(object):
             str: The cleaned and lemmatized text.
         """
         if not isinstance(text, str):
-            raise ValueError(f"{self.__class__.__name__}: preprocess_text expects a string, got {type(text)}")
+            raise ValueError(
+                f"{self.__class__.__name__}: preprocess_text expects a string, got {type(text)}"
+            )
         text = text.lower()
         text = re.sub(r"http\S+", "", text)
         text = re.sub(r"[^a-zA-Z\s]", "", text)
@@ -479,8 +485,96 @@ class SentimentAnalyzer(object):
         )
         return avg_sentiment
 
+    def _get_sentiment_for_one_ticker(
+        self,
+        ticker: str,
+        asset_type: str,
+        lexicon=None,
+        top_news=10,
+        **kwargs,
+    ) -> float:
+        rd_params = {"client_id", "client_secret", "user_agent"}
+        fm_params = {"start", "end", "page", "limit"}
+
+        # 1. Collect data from all sources
+        yahoo_news = self.news.get_yahoo_finance_news(
+            ticker, asset_type=asset_type, n_news=top_news
+        )
+        google_news = self.news.get_google_finance_news(
+            ticker, asset_type=asset_type, n_news=top_news
+        )
+
+        reddit_posts = []
+        if all(kwargs.get(rd) for rd in rd_params):
+            reddit_posts = self.news.get_reddit_posts(
+                ticker,
+                n_posts=top_news,
+                **{k: kwargs.get(k) for k in rd_params},
+            )
+
+        coindesk_news = self.news.get_coindesk_news(query=ticker, list_of_str=True)
+
+        fmp_source_news = []
+        if kwargs.get("fmp_api"):
+            fmp_news_client = self.news.get_fmp_news(kwargs.get("fmp_api"))
+            for src in ["articles"]:
+                try:
+                    source_news = fmp_news_client.get_news(
+                        ticker,
+                        source=src,
+                        symbol=ticker,
+                        **{k: kwargs.get(k) for k in fm_params},
+                    )
+                    fmp_source_news.extend(source_news)
+                except Exception:
+                    continue
+
+        # 2. Analyze sentiment for each source
+        news_sentiment = self.analyze_sentiment(
+            yahoo_news + google_news, lexicon=lexicon
+        )
+        reddit_sentiment = self.analyze_sentiment(
+            reddit_posts, lexicon=lexicon, textblob=True
+        )
+        fmp_sentiment = self.analyze_sentiment(
+            fmp_source_news, lexicon=lexicon, textblob=True
+        )
+        coindesk_sentiment = self.analyze_sentiment(
+            coindesk_news, lexicon=lexicon, textblob=True
+        )
+
+        # 3. Compute weighted average sentiment score
+        sentiments = [
+            news_sentiment,
+            reddit_sentiment,
+            fmp_sentiment,
+            coindesk_sentiment,
+        ]
+        # Count how many sources provided data to get a proper average
+        num_sources = sum(
+            1
+            for source_data in [
+                yahoo_news + google_news,
+                reddit_posts,
+                fmp_source_news,
+                coindesk_news,
+            ]
+            if source_data
+        )
+
+        if num_sources == 0:
+            return 0.0
+
+        overall_sentiment = sum(sentiments) / num_sources
+        return overall_sentiment
+
     def get_sentiment_for_tickers(
-        self, tickers: List[str] | List[Tuple[str, str]], lexicon=None, asset_type="stock", top_news=10, **kwargs
+        self,
+        tickers: List[str] | List[Tuple[str, str]],
+        lexicon=None,
+        asset_type="stock",
+        top_news=10,
+        **kwargs,
     ) -> Dict[str, float]:
         """
         Computes sentiment scores for a list of financial tickers based on news and social media data.
@@ -501,7 +595,7 @@ class SentimentAnalyzer(object):
                 - if using tuples, the first element is the ticker and the second is the asset type.
                 - if using a single string, the asset type must be specified or the default is "stock".
             lexicon (dict, optional): A custom sentiment lexicon to update VADER's default lexicon.
-            asset_type (str, optional): The type of asset, Defaults to "stock",                
+            asset_type (str, optional): The type of asset, Defaults to "stock",
                 supported types include:
                 - "stock": Stock symbols (e.g., AAPL, MSFT)
                 - "etf": Exchange-traded funds (e.g., SPY, QQQ)
@@ -522,82 +616,58 @@ class SentimentAnalyzer(object):
         Notes:
             The tickers names must follow yahoo finance conventions.
         """
+
         sentiment_results = {}
-        rd_params = {"client_id", "client_secret", "user_agent"}
-        fm_params = {"start", "end", "page", "limit"}
-        with open(os.devnull, 'w') as devnull:
-            with contextlib.redirect_stdout(devnull), contextlib.redirect_stderr(devnull):
-                for asset in tickers:
-                    if isinstance(asset, tuple):
-                        ticker, asset_type = asset
-                    if asset_type not in [
-                        "stock",
-                        "etf",
-                        "future",
-                        "forex",
-                        "crypto",
-                        "index",
-                    ]:
-                        raise ValueError(
-                            f"Unsupported asset type '{asset_type}'. "
-                            "Supported types: stock, etf, future, forex, crypto, index."
-                        )
-                    # Collect data
-                    sources = 0
-                    yahoo_news = self.news.get_yahoo_finance_news(
-                        ticker, asset_type=asset_type, n_news=top_news
-                    )
-                    google_news = self.news.get_google_finance_news(
-                        ticker, asset_type=asset_type, n_news=top_news
-                    )
-                    reddit_posts = []
-                    if all(kwargs.get(rd) for rd in rd_params):
-                        reddit_posts = self.news.get_reddit_posts(
-                            ticker, n_posts=top_news, **{k: kwargs.get(k) for k in rd_params}
-                        )
-                    coindesk_news = self.news.get_coindesk_news(query=ticker, list_of_str=True)
-                    fmp_source_news = []
-                    if kwargs.get("fmp_api"):
-                        fmp_news = self.news.get_fmp_news(kwargs.get("fmp_api"))
-                        for src in ["articles"]:  # , "releases", asset_type]:
-                            try:
-                                source_news = fmp_news.get_news(
-                                    ticker, source=src, symbol=ticker, **{k: kwargs.get(k) for k in fm_params}
-                                )
-                                fmp_source_news += source_news
-                            except Exception:
-                                continue
-                    if any([len(s) > 0 for s in [yahoo_news, google_news]]):
-                        sources += 1
-                    for source in [reddit_posts, fmp_source_news, coindesk_news]:
-                        if len(source) > 0:
-                            sources += 1
-                    # Compute sentiment
-                    news_sentiment = self.analyze_sentiment(
-                        yahoo_news + google_news, lexicon=lexicon
-                    )
-                    reddit_sentiment = self.analyze_sentiment(
-                        reddit_posts, lexicon=lexicon, textblob=True
-                    )
-                    fmp_sentiment = self.analyze_sentiment(
-                        fmp_source_news, lexicon=lexicon, textblob=True
-                    )
-                    coindesk_sentiment = self.analyze_sentiment(
-                        coindesk_news, lexicon=lexicon, textblob=True
-                    )
 
-                    # Weighted average sentiment score
-                    if sources != 0:
-                        overall_sentiment = (
-                            news_sentiment
-                            + reddit_sentiment
-                            + fmp_sentiment
-                            + coindesk_sentiment
-                        ) / sources
-                    else:
-                        overall_sentiment = 0.0
-                    sentiment_results[ticker] = overall_sentiment
-                    time.sleep(1)  # To avoid hitting API rate limits
+        # Suppress stdout/stderr from underlying  libraries during execution
+        with open(os.devnull, "w") as devnull:
+            with (
+                contextlib.redirect_stdout(devnull),
+                contextlib.redirect_stderr(devnull),
+            ):
+                with ThreadPoolExecutor() as executor:
+                    # Map each future to its ticker for easy result lookup
+                    future_to_ticker = {}
+                    for ticker_info in tickers:
+                        # Normalize input to (ticker, asset_type)
+                        if isinstance(ticker_info, tuple):
+                            ticker_symbol, ticker_asset_type = ticker_info
+                        else:
+                            ticker_symbol, ticker_asset_type = ticker_info, asset_type
+
+                        if ticker_asset_type not in [
+                            "stock",
+                            "etf",
+                            "future",
+                            "forex",
+                            "crypto",
+                            "index",
+                        ]:
+                            raise ValueError(
+                                f"Unsupported asset type '{ticker_asset_type}' for {ticker_symbol}."
+                            )
+
+                        # Submit the job to the thread pool
+                        future = executor.submit(
+                            self._get_sentiment_for_one_ticker,
+                            ticker=ticker_symbol,
+                            asset_type=ticker_asset_type,
+                            lexicon=lexicon,
+                            top_news=top_news,
+                            **kwargs,
+                        )
+                        future_to_ticker[future] = ticker_symbol
+
+                    # Collect results as they are completed
+                    for future in as_completed(future_to_ticker):
+                        ticker_symbol = future_to_ticker[future]
+                        try:
+                            sentiment_score = future.result()
+                            sentiment_results[ticker_symbol] = sentiment_score
+                        except Exception:
+                            sentiment_results[ticker_symbol] = (
+                                0.0  # Assign a neutral score on error
+                            )
 
         return sentiment_results
 

bbstrader/models/optimization.py

@@ -153,7 +153,7 @@ def optimized_weights(prices=None, returns=None, rfr=0.0, freq=252, method="equa
     freq : int, optional
         Number of days for calculating portfolio weights, such as 252 for a year's worth of daily returns (default is 252).
     method : str, optional
-        Optimization method to use ('markowitz', 'hrp', or 'equal') (default is 'markowitz').
+        Optimization method to use ('markowitz', 'hrp', or 'equal') (default is 'equal').
 
     Returns
     -------