bbstrader 0.3.0__py3-none-any.whl → 0.3.2__py3-none-any.whl

bbstrader/models/nlp.py

@@ -1,14 +1,17 @@
+import contextlib
+import os
 import re
 import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
 from datetime import datetime
-from typing import Dict
+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 spacy
 from dash import dcc, html
 from dash.dependencies import Input, Output
 from nltk.corpus import stopwords
@@ -335,13 +338,12 @@ class TopicModeler(object):
         nltk.download("stopwords", quiet=True)
 
         try:
-            self.nlp = spacy.load("en_core_web_sm")
+            self.nlp = en_core_web_sm.load()
             self.nlp.disable_pipes("ner")
         except OSError:
-            raise RuntimeError(
-                "The SpaCy model 'en_core_web_sm' is not installed.\n"
-                "Please install it by running:\n"
-                "   python -m spacy download en_core_web_sm"
+            raise OSError(
+                "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]):
@@ -392,22 +394,25 @@ class SentimentAnalyzer(object):
         - Downloads NLTK tokenization (`punkt`) and stopwords.
         - 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)
 
+        self.analyzer = SentimentIntensityAnalyzer()
+        self._stopwords = set(stopwords.words("english"))
+
         try:
-            self.nlp = spacy.load("en_core_web_sm")
+            self.nlp = en_core_web_sm.load()
             self.nlp.disable_pipes("ner")
         except OSError:
-            raise RuntimeError(
-                "The SpaCy model 'en_core_web_sm' is not installed.\n"
-                "Please install it by running:\n"
-                "   python -m spacy download en_core_web_sm"
+            raise OSError(
+                "SpaCy model 'en_core_web_sm' not found. "
+                "Please install it using 'python -m spacy download en_core_web_sm'."
             )
-
-        self.analyzer = SentimentIntensityAnalyzer()
-        self._stopwords = set(stopwords.words("english"))
+        self.news = FinancialNews()
 
     def preprocess_text(self, text: str):
         """
@@ -425,13 +430,20 @@ class SentimentAnalyzer(object):
         Returns:
             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)}"
+            )
         text = text.lower()
         text = re.sub(r"http\S+", "", text)
         text = re.sub(r"[^a-zA-Z\s]", "", text)
+
         words = word_tokenize(text)
         words = [word for word in words if word not in self._stopwords]
+
         doc = self.nlp(" ".join(words))
         words = [t.lemma_ for t in doc if t.lemma_ != "-PRON-"]
+
         return " ".join(words)
 
     def analyze_sentiment(self, texts, lexicon=None, textblob=False) -> float:
@@ -469,8 +481,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, 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.
@@ -487,9 +587,18 @@ class SentimentAnalyzer(object):
         3. Computes an overall sentiment score using a weighted average approach.
 
         Args:
-            tickers (list of str): A list of stock, forex, crypto, or other asset tickers.
+            tickers (List[str] | List[Tuple[str, str]]): A list of asset tickers to analyze
+                - 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 (e.g., "stock", "forex", "crypto"). 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)
+                - "future": Futures contracts (e.g., CL=F for crude oil)
+                - "forex": Forex pairs (e.g., EURUSD=X, USDJPY=X)
+                - "crypto": Cryptocurrency pairs (e.g., BTC-USD, ETH-USD)
+                - "index": Stock market indices (e.g., ^GSPC for S&P 500)
             top_news (int, optional): Number of news articles/posts to fetch per source. Defaults to 10.
             **kwargs: Additional parameters for API authentication and data retrieval, including:
                 - fmp_api (str): API key for Financial Modeling Prep.
@@ -500,63 +609,60 @@ class SentimentAnalyzer(object):
                              - Positive values indicate positive sentiment.
                              - Negative values indicate negative sentiment.
                              - Zero indicates neutral sentiment.
+        Notes:
+            The tickers names must follow yahoo finance conventions.
         """
+
         sentiment_results = {}
-        rd_params = ["client_id", "client_secret", "user_agent"]
-        news = FinancialNews()
-        for ticker in tickers:
-            # Collect data
-            sources = 0
-            yahoo_news = news.get_yahoo_finance_news(
-                ticker, asset_type=asset_type, n_news=top_news
-            )
-            google_news = news.get_google_finance_news(
-                ticker, asset_type=asset_type, n_news=top_news
-            )
-            reddit_posts = news.get_reddit_posts(
-                ticker, n_posts=top_news, **{k: kwargs.get(k) for k in rd_params}
-            )
-            coindesk_news = news.get_coindesk_news(query=ticker, list_of_str=True)
-            fmp_source_news = []
-            fmp_news = news.get_fmp_news(kwargs.get("fmp_api"))
-            for source in ["articles"]:  # , "releases", asset_type]:
-                try:
-                    source_news = fmp_news.get_news(
-                        ticker, source=source, symbol=ticker, **kwargs
-                    )
-                    fmp_source_news += source_news
-                except Exception:
-                    source_news = []
-            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
+        # 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
 
@@ -651,8 +757,10 @@ class SentimentAnalyzer(object):
         bar and scatter plots. It fetches new sentiment data at specified intervals.
 
         Args:
-            tickers (list[str]):
-                A list of asset tickers (e.g., ["AAPL", "GOOGL", "TSLA"]).
+            tickers (List[str] | List[Tuple[str, str]]):
+                A list of financial asset tickers to analyze.
+                - 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 defaults to "stock".
             asset_type (str, optional):
                 The type of financial asset ("stock", "forex", "crypto"). Defaults to "stock".
             lexicon (dict, optional):

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