yfinance logging

app.py

@@ -126,37 +126,68 @@ class AlpacaTrader:
 
 class NewsSentiment:
     def __init__(self, API_KEY):
-        '''
-        Hutto, C.J. & Gilbert, E.E. (2014). VADER: A Parsimonious Rule-based Model for Sentiment Analysis of Social Media Text. Eighth International Conference on Weblogs and Social Media (ICWSM-14). Ann Arbor, MI, June 2014.
-        '''
         self.newsapi = NewsApiClient(api_key=API_KEY)
         self.sia = SentimentIntensityAnalyzer()
 
-    def get_news_sentiment(self, symbols):
-        '''
-        The News API has a rate limit of 100 requests per day for free accounts. If you exceed this limit, you'll get a rateLimited error. Example error message:
-        ERROR:__main__:Error getting news for APLD: {'status': 'error', 'code': 'rateLimited', 'message': 'You have made too many requests recently. Developer accounts are limited to 100 requests over a 24 hour period (50 requests available every 12 hours). Please upgrade to a paid plan if you need more requests.'}
-        
-        '''
+    def get_sentiment_and_headlines(self, symbol):
+        """
+        Try NewsAPI first, fallback to yfinance if needed.
+        Returns (sentiment, headlines).
+        """
+        # Try NewsAPI
+        try:
+            articles = self.newsapi.get_everything(q=symbol, language='en', sort_by='publishedAt', page=1)
+            headlines = [a['title'] for a in articles.get('articles', [])[:5]]
+            if headlines:
+                sentiment = self._calculate_sentiment(headlines)
+                return sentiment, headlines
+            else:
+                logger.warning(f"NewsAPI returned no headlines for {symbol}.")
+        except Exception as e:
+            logger.error(f"NewsAPI error for {symbol}: {e}")
+            # Explicitly log that fallback will be attempted
+            logger.info(f"Falling back to yfinance for {symbol} sentiment and headlines.")
+
+        # Fallback to yfinance
+        try:
+            ticker = yf.Ticker(symbol)
+            news_items = ticker.news if hasattr(ticker, "news") else []
+            headlines = [item.get('title') for item in news_items[:5] if item.get('title')]
+            if headlines:
+                logger.info(f"Using yfinance headlines for {symbol}: {headlines}")
+                sentiment = self._calculate_sentiment(headlines)
+                return sentiment, headlines
+            else:
+                logger.warning(f"yfinance returned no headlines for {symbol}.")
+        except Exception as e:
+            logger.error(f"yfinance error for {symbol}: {e}")
+
+        logger.info(f"No sentiment/headlines available for {symbol} from either NewsAPI or yfinance.")
+        return None, []
+
+    def _calculate_sentiment(self, headlines):
+        if not headlines:
+            return None
+        compound_score = sum(self.sia.polarity_scores(title)['compound'] for title in headlines)
+        avg_score = compound_score / len(headlines)
+        if avg_score > 0.1:
+            return 'Positive'
+        elif avg_score < -0.1:
+            return 'Negative'
+        else:
+            return 'Neutral'
+
+    def get_sentiment_bulk(self, symbols):
+        """
+        Bulk sentiment for a list of symbols using NewsAPI only (for auto-trade).
+        Returns dict: symbol -> sentiment.
+        """
         sentiment = {}
         for symbol in symbols:
             try:
-                articles = self.newsapi.get_everything(q=symbol,
-                                                       language='en',
-                                                       sort_by='publishedAt',  # <-- fixed argument name
-                                                       page=1)
-                compound_score = 0
-                for article in articles['articles'][:5]:  # Check first 5 articles
-                    # print(f'article= {article}')
-                    score = self.sia.polarity_scores(article['title'])['compound']
-                    compound_score += score
-                avg_score = compound_score / 5 if articles['articles'] else 0
-                if avg_score > 0.1:
-                    sentiment[symbol] = 'Positive'
-                elif avg_score < -0.1:
-                    sentiment[symbol] = 'Negative'
-                else:
-                    sentiment[symbol] = 'Neutral'
+                articles = self.newsapi.get_everything(q=symbol, language='en', sort_by='publishedAt', page=1)
+                headlines = [a['title'] for a in articles.get('articles', [])[:5]]
+                sentiment[symbol] = self._calculate_sentiment(headlines) if headlines else 'Neutral'
             except Exception as e:
                 logger.error(f"Error getting news for {symbol}: {e}")
                 sentiment[symbol] = 'Neutral'
@@ -302,51 +333,6 @@ class TradingApp:
         self.data = self.analyzer.get_historical_data(self.analyzer.symbols)
         self.auto_trade_log = []  # Store automatic trade actions
 
-    def get_newsapi_sentiment_and_headlines(self, symbol):
-        """Get sentiment and headlines using NewsAPI for a symbol."""
-        sentiment_result = None
-        article_headlines = []
-        try:
-            sentiment_dict = self.sentiment.get_news_sentiment([symbol])
-            sentiment_result = sentiment_dict.get(symbol)
-            articles = self.sentiment.newsapi.get_everything(q=symbol, language='en', sort_by='publishedAt', page=1)
-            article_headlines = [a['title'] for a in articles.get('articles', [])[:5]]
-        except Exception as e:
-            logger.error(f"NewsAPI sentiment/headlines error for {symbol}: {e}")
-        return sentiment_result, article_headlines
-
-    def get_yfinance_sentiment_and_headlines(self, symbol):
-        """Get sentiment and headlines using yfinance for a symbol."""
-        sentiment_result = None
-        article_headlines = []
-        try:
-            ticker = yf.Ticker(symbol)
-            news_items = ticker.news if hasattr(ticker, "news") else []
-            article_headlines = [item.get('title') for item in news_items[:5] if item.get('title')]
-            # Use VADER on yfinance headlines if available
-            if article_headlines:
-                compound_score = 0
-                for title in article_headlines:
-                    score = self.sentiment.sia.polarity_scores(title)['compound']
-                    compound_score += score
-                avg_score = compound_score / len(article_headlines)
-                if avg_score > 0.1:
-                    sentiment_result = 'Positive'
-                elif avg_score < -0.1:
-                    sentiment_result = 'Negative'
-                else:
-                    sentiment_result = 'Neutral'
-        except Exception as e:
-            logger.error(f"yfinance sentiment/headlines error for {symbol}: {e}")
-        return sentiment_result, article_headlines
-
-    def get_combined_sentiment_and_headlines(self, symbol):
-        """Try NewsAPI first, fallback to yfinance if needed."""
-        sentiment_result, article_headlines = self.get_newsapi_sentiment_and_headlines(symbol)
-        if not article_headlines:
-            sentiment_result, article_headlines = self.get_yfinance_sentiment_and_headlines(symbol)
-        return sentiment_result, article_headlines
-
     def display_charts(self):
         # Dynamically adjust columns based on number of stocks and available width
         symbols = list(self.data.keys())
@@ -401,7 +387,7 @@ class TradingApp:
             st.header("Manual Trade")
             symbol = st.text_input('Enter stock symbol')
 
-            # --- Sentiment Check Feature (fixed with session state) ---
+            # --- Unified Sentiment Check Feature ---
             if "sentiment_result" not in st.session_state:
                 st.session_state["sentiment_result"] = None
             if "article_headlines" not in st.session_state:
@@ -409,7 +395,7 @@ class TradingApp:
 
             if st.button("Check Sentiment"):
                 if symbol:
-                    sentiment_result, article_headlines = self.get_combined_sentiment_and_headlines(symbol)
+                    sentiment_result, article_headlines = self.sentiment.get_sentiment_and_headlines(symbol)
                     st.session_state["sentiment_result"] = sentiment_result
                     st.session_state["article_headlines"] = article_headlines
                     st.session_state["sentiment_symbol"] = symbol
@@ -418,7 +404,6 @@ class TradingApp:
                     st.session_state["article_headlines"] = []
                     st.session_state["sentiment_symbol"] = ""
 
-            # Always display the last checked sentiment/headlines for the current symbol
             sentiment_result = st.session_state.get("sentiment_result")
             article_headlines = st.session_state.get("article_headlines", [])
             sentiment_symbol = st.session_state.get("sentiment_symbol", "")
@@ -515,20 +500,17 @@ class TradingApp:
             st.button("Refresh Portfolio", on_click=refresh_portfolio)
 
     def auto_trade_based_on_sentiment(self, sentiment):
-        """Execute trades based on sentiment analysis and return actions taken."""
         actions = self._execute_sentiment_trades(sentiment)
         self.auto_trade_log = actions
         return actions
 
     def _execute_sentiment_trades(self, sentiment):
-        """Helper method to execute trades based on sentiment.
-        Used by both auto_trade_based_on_sentiment and background_auto_trade."""
         actions = []
         symbol_to_name = self.analyzer.symbol_to_name
         for symbol, sentiment_value in sentiment.items():
-            # Use refactored sentiment logic for each symbol
+            # If sentiment is missing or invalid, try to get it using fallback
             if sentiment_value is None or sentiment_value not in ['Positive', 'Negative', 'Neutral']:
-                sentiment_value, _ = self.get_combined_sentiment_and_headlines(symbol)
+                sentiment_value, _ = self.sentiment.get_sentiment_and_headlines(symbol)
             action = None
             is_market_open = self.alpaca.get_market_status()
             if sentiment_value == 'Positive':
@@ -561,37 +543,23 @@ class TradingApp:
 def background_auto_trade(app):
     """This function runs in a background thread and updates session state with automatic trades."""
     while True:
-        start_time = time.time()  # Record the start time of the iteration
-        
-        sentiment = app.sentiment.get_news_sentiment(app.analyzer.symbols)
-        
-        # Use the shared method to execute trades
+        start_time = time.time()
+        # Use NewsAPI only for bulk sentiment (to avoid rate limits and speed)
+        sentiment = app.sentiment.get_sentiment_bulk(app.analyzer.symbols)
         actions = app._execute_sentiment_trades(sentiment)
-        
-        # Create log entry
         log_entry = {
             "timestamp": datetime.now().isoformat(),
             "actions": actions,
             "sentiment": sentiment
         }
-        
-        # Update session state - ensure the UI reflects the latest data
         if AUTO_TRADE_LOG_KEY not in st.session_state:
             st.session_state[AUTO_TRADE_LOG_KEY] = []
-        
         st.session_state[AUTO_TRADE_LOG_KEY].append(log_entry)
-        
-        # Limit size to avoid memory issues (keep last 50 entries)
         if len(st.session_state[AUTO_TRADE_LOG_KEY]) > 50:
             st.session_state[AUTO_TRADE_LOG_KEY] = st.session_state[AUTO_TRADE_LOG_KEY][-50:]
-        
-        # Log the update
         logger.info(f"Auto-trade completed. Actions: {actions}")
-        
-        # Calculate the time taken for this iteration
         elapsed_time = time.time() - start_time
-        sleep_time = max(0, AUTO_TRADE_INTERVAL - elapsed_time)  # Ensure non-negative sleep time
-        
+        sleep_time = max(0, AUTO_TRADE_INTERVAL - elapsed_time)
         logger.info(f"Sleeping for {sleep_time:.2f} seconds before the next auto-trade.")
         time.sleep(sleep_time)