Add earnings calendar column to Market Intelligence and fix thread exhaustion

- Add 4th column to Market Intelligence showing upcoming earnings reports
for top companies as a scrollable table (date, EPS estimate, urgency
color coding). Data fetched from Alpha Vantage EARNINGS_CALENDAR with
StockAnalysis.com as fallback, no mock data.
- Fix RuntimeError: can't start new thread by reducing ThreadPoolExecutor
workers from 8→4 and adding a sequential fallback when thread creation
fails.
- Harden source count references to use _TOTAL_SOURCES instead of
hardcoded "8 sources".

app/components/news.py

@@ -721,3 +721,89 @@ def display_economic_calendar_widget(events_df: pd.DataFrame):
     widget_html += "</div>"
 
     st.markdown(widget_html, unsafe_allow_html=True)
+
+
+def display_earnings_calendar(entries: list, height: str = "600px"):
+    """Display upcoming earnings reports as a scrollable table."""
+
+    header_html = """<div style="background: linear-gradient(135deg, #2A2E39 0%, #1E222D 100%); border: 1px solid #363A45; border-radius: 8px 8px 0 0; padding: 16px 20px;">
+<div style="display: flex; justify-content: space-between; align-items: center;">
+<div>
+<h3 style="color: #D1D4DC; margin: 0; font-size: 18px; font-weight: 600;">📋 Earnings Calendar</h3>
+<p style="color: #787B86; margin: 4px 0 0 0; font-size: 12px;">Upcoming financial reports · Top companies</p>
+</div>
+<div style="background: rgba(56, 97, 251, 0.15); color: #3861FB; padding: 6px 12px; border-radius: 6px; font-size: 13px; font-weight: 600;">{count} reports</div>
+</div>
+</div>""".format(count=len(entries))
+
+    st.markdown(header_html, unsafe_allow_html=True)
+
+    if not entries:
+        st.markdown("""
+        <div style="background: #131722; border: 1px solid #2A2E39; border-radius: 0 0 8px 8px; padding: 30px; text-align: center; color: #787B86;">
+            No upcoming earnings data available
+        </div>""", unsafe_allow_html=True)
+        return
+
+    # Column header row
+    col_header = """<div style="background: #131722; border-left: 1px solid #2A2E39; border-right: 1px solid #2A2E39; padding: 8px 14px; display: flex; gap: 0;">
+<div style="color: #787B86; font-size: 11px; font-weight: 600; text-transform: uppercase; flex: 2;">Company</div>
+<div style="color: #787B86; font-size: 11px; font-weight: 600; text-transform: uppercase; flex: 2; text-align: center;">Date</div>
+<div style="color: #787B86; font-size: 11px; font-weight: 600; text-transform: uppercase; flex: 1; text-align: center;">When</div>
+<div style="color: #787B86; font-size: 11px; font-weight: 600; text-transform: uppercase; flex: 1; text-align: right;">EPS Est.</div>
+</div>"""
+
+    # Build scrollable rows
+    rows_html = ""
+    for entry in entries:
+        days = entry.get("days_until", 0)
+        date: datetime = entry["date"]
+        ticker = html_module.escape(entry["ticker"])
+        company = html_module.escape(entry["company"])
+
+        # Urgency color
+        if days == 0:
+            urgency_color = "#F23645"   # red  — today
+            when_label = "Today"
+        elif days == 1:
+            urgency_color = "#FF9800"   # orange — tomorrow
+            when_label = "Tomorrow"
+        elif days <= 7:
+            urgency_color = "#F0B429"   # yellow — this week
+            when_label = f"in {days}d"
+        else:
+            urgency_color = "#787B86"   # grey — further out
+            when_label = f"in {days}d"
+
+        date_str = date.strftime("%b %d, %Y")
+
+        report_time = entry.get("report_time")
+        time_badge = ""
+        if report_time == "BMO":
+            time_badge = ' <span style="color:#089981; font-size:10px; background:rgba(8,153,129,0.1); padding:1px 5px; border-radius:3px;">BMO</span>'
+        elif report_time == "AMC":
+            time_badge = ' <span style="color:#3861FB; font-size:10px; background:rgba(56,97,251,0.1); padding:1px 5px; border-radius:3px;">AMC</span>'
+
+        eps = entry.get("eps_estimate")
+        eps_str = f"${eps:.2f}" if eps is not None else "—"
+
+        row = f"""<div style="display: flex; gap: 0; padding: 9px 14px; border-bottom: 1px solid #1E222D; align-items: center;">
+<div style="flex: 2; min-width: 0;">
+<span style="color: #D1D4DC; font-size: 13px; font-weight: 600;">{ticker}</span>
+<span style="color: #787B86; font-size: 11px; margin-left: 5px; white-space: nowrap; overflow: hidden; text-overflow: ellipsis;">{company}</span>
+{time_badge}
+</div>
+<div style="flex: 2; color: #B2B5BE; font-size: 12px; text-align: center;">{date_str}</div>
+<div style="flex: 1; text-align: center;">
+<span style="color: {urgency_color}; font-size: 12px; font-weight: 600;">{when_label}</span>
+</div>
+<div style="flex: 1; color: #D1D4DC; font-size: 13px; font-weight: 500; text-align: right;">{eps_str}</div>
+</div>"""
+        rows_html += row
+
+    scroll_container = f"""<div style="background: #131722; border: 1px solid #2A2E39; border-top: none; border-radius: 0 0 8px 8px; overflow-y: auto; height: {height};">
+{col_header}
+{rows_html}
+</div>"""
+
+    st.markdown(scroll_container, unsafe_allow_html=True)

app/pages/05_Dashboard.py

@@ -23,7 +23,8 @@ from components.news import (
     display_scrollable_news_section,
     display_prediction_card,
     display_economic_event_card,
-    display_economic_calendar_widget
+    display_economic_calendar_widget,
+    display_earnings_calendar,
 )
 from utils.breaking_news_scorer import get_breaking_news_scorer
 from utils.ai_summary_store import init_storage, enqueue_items, fetch_summaries, get_status
@@ -78,6 +79,12 @@ try:
 except ImportError:
     CALENDAR_AVAILABLE = False
 
+try:
+    from services.earnings_calendar import EarningsCalendarService
+    EARNINGS_AVAILABLE = True
+except ImportError:
+    EARNINGS_AVAILABLE = False
+
 
 # ---- Page Configuration ----
 st.set_page_config(
@@ -115,6 +122,12 @@ if 'market_events_monitor' not in st.session_state and EVENTS_AVAILABLE:
 if 'economic_calendar_service' not in st.session_state and CALENDAR_AVAILABLE:
     st.session_state.economic_calendar_service = EconomicCalendarService()
 
+if 'earnings_calendar_service' not in st.session_state and EARNINGS_AVAILABLE:
+    from utils.config import Config
+    st.session_state.earnings_calendar_service = EarningsCalendarService(
+        api_key=Config.ALPHA_VANTAGE_KEY or None
+    )
+
 rss_monitor = st.session_state.get('rss_monitor')
 twitter_monitor = st.session_state.get('twitter_monitor')
 reddit_monitor = st.session_state.get('reddit_monitor')
@@ -123,6 +136,7 @@ prediction_markets_monitor = st.session_state.get('prediction_markets_monitor')
 sectoral_news_monitor = st.session_state.get('sectoral_news_monitor')
 market_events_monitor = st.session_state.get('market_events_monitor')
 economic_calendar_service = st.session_state.get('economic_calendar_service')
+earnings_calendar_service = st.session_state.get('earnings_calendar_service')
 
 # Initialize unified cache manager
 if 'news_cache_manager' not in st.session_state:
@@ -283,6 +297,7 @@ predictions_df = pd.DataFrame()
 sectoral_news_df = pd.DataFrame()
 market_events_df = pd.DataFrame()
 economic_calendar_df = pd.DataFrame()
+earnings_data = []  # List[Dict] from EarningsCalendarService
 
 def fetch_twitter_news():
     """Fetch Twitter/X news via cache manager"""
@@ -445,6 +460,16 @@ def fetch_economic_calendar():
         return pd.DataFrame(), f"Economic calendar unavailable: {e}"
     return pd.DataFrame(), None
 
+def fetch_earnings_calendar():
+    """Fetch upcoming earnings reports for top companies"""
+    try:
+        if earnings_calendar_service:
+            entries = earnings_calendar_service.get_upcoming_earnings(days_ahead=30)
+            return entries, None
+    except Exception as e:
+        return [], f"Earnings calendar unavailable: {e}"
+    return [], None
+
 # Progressive loading: Display results as they arrive
 # Create a status placeholder to show progress
 status_placeholder = st.empty()
@@ -459,36 +484,41 @@ _fetch_tasks = [
     (fetch_sectoral_news, 'sectoral_news'),
     (fetch_market_events, 'market_events'),
     (fetch_economic_calendar, 'economic_calendar'),
+    (fetch_earnings_calendar, 'earnings_calendar'),
 ]
+_TOTAL_SOURCES = len(_fetch_tasks)
 
-def _apply_result(source_name, result_df, error):
+def _apply_result(source_name, result, error):
     global twitter_df, reddit_df, rss_all_df, rss_main_df, ai_tech_df
     global predictions_df, sectoral_news_df, market_events_df, economic_calendar_df
+    global earnings_data
     if source_name == 'twitter':
-        twitter_df = result_df
+        twitter_df = result
     elif source_name == 'reddit':
-        reddit_df = result_df
+        reddit_df = result
     elif source_name == 'rss':
-        rss_all_df = result_df
+        rss_all_df = result
         if not rss_all_df.empty and 'from_web' in rss_all_df.columns:
             rss_main_df = rss_all_df[rss_all_df['from_web'] == True].copy()
     elif source_name == 'ai_tech':
-        ai_tech_df = result_df
+        ai_tech_df = result
     elif source_name == 'predictions':
-        predictions_df = result_df
+        predictions_df = result
     elif source_name == 'sectoral_news':
-        sectoral_news_df = result_df
+        sectoral_news_df = result
     elif source_name == 'market_events':
-        market_events_df = result_df
+        market_events_df = result
     elif source_name == 'economic_calendar':
-        economic_calendar_df = result_df
+        economic_calendar_df = result
+    elif source_name == 'earnings_calendar':
+        earnings_data = result
     if error:
         fetch_errors.append(error)
 
 fetch_errors = []
 completed_sources = []
 
-with st.spinner("Loading news from 8 sources..."):
+with st.spinner(f"Loading news from {_TOTAL_SOURCES} sources..."):
     try:
         with ThreadPoolExecutor(max_workers=4) as executor:
             futures_map = {executor.submit(fn): name for fn, name in _fetch_tasks}
@@ -496,17 +526,17 @@ with st.spinner("Loading news from 8 sources..."):
                 for future in as_completed(futures_map, timeout=90):
                     source_name = futures_map[future]
                     try:
-                        result_df, error = future.result()
+                        result, error = future.result()
                         completed_sources.append(source_name)
-                        status_placeholder.info(f"🔍 Loaded {len(completed_sources)}/8 sources ({', '.join(completed_sources)})")
-                        _apply_result(source_name, result_df, error)
+                        status_placeholder.info(f"🔍 Loaded {len(completed_sources)}/{_TOTAL_SOURCES} sources ({', '.join(completed_sources)})")
+                        _apply_result(source_name, result, error)
                     except Exception as e:
                         fetch_errors.append(f"Error fetching {source_name} news: {e}")
                         completed_sources.append(f"{source_name} (error)")
                         status_placeholder.warning(f"⚠️ {source_name} failed, continuing with other sources...")
             except TimeoutError:
                 fetch_errors.append("⏱️ Some sources timed out after 90 seconds - displaying available results")
-                status_placeholder.warning(f"⚠️ {len(completed_sources)}/8 sources loaded (some timed out)")
+                status_placeholder.warning(f"⚠️ {len(completed_sources)}/{_TOTAL_SOURCES} sources loaded (some timed out)")
                 all_sources = set(futures_map.values())
                 for source in all_sources - set(completed_sources):
                     fetch_errors.append(f"{source} timed out - skipped")
@@ -516,21 +546,21 @@ with st.spinner("Loading news from 8 sources..."):
         fetch_errors.append("⚠️ Thread limit reached, falling back to sequential fetch")
         for fn, name in _fetch_tasks:
             try:
-                result_df, error = fn()
+                result, error = fn()
                 completed_sources.append(name)
-                status_placeholder.info(f"🔍 Loaded {len(completed_sources)}/8 sources (sequential mode)")
-                _apply_result(name, result_df, error)
+                status_placeholder.info(f"🔍 Loaded {len(completed_sources)}/{_TOTAL_SOURCES} sources (sequential mode)")
+                _apply_result(name, result, error)
             except Exception as e:
                 fetch_errors.append(f"Error fetching {name} news: {e}")
                 completed_sources.append(f"{name} (error)")
 
     # Clear the status message after all sources complete
-    status_placeholder.success(f"✅ Loaded {len(completed_sources)}/8 sources successfully")
+    status_placeholder.success(f"✅ Loaded {len(completed_sources)}/{_TOTAL_SOURCES} sources successfully")
 
 # Debug logging (console only, not displayed on page)
 import logging
 logger = logging.getLogger(__name__)
-logger.info(f"News Fetch Results: Twitter={len(twitter_df)}, Reddit={len(reddit_df)}, RSS={len(rss_all_df)}, AI/Tech={len(ai_tech_df)}, Predictions={len(predictions_df)}, Sectoral={len(sectoral_news_df)}, Events={len(market_events_df)}, Calendar={len(economic_calendar_df)}")
+logger.info(f"News Fetch Results: Twitter={len(twitter_df)}, Reddit={len(reddit_df)}, RSS={len(rss_all_df)}, AI/Tech={len(ai_tech_df)}, Predictions={len(predictions_df)}, Sectoral={len(sectoral_news_df)}, Events={len(market_events_df)}, Calendar={len(economic_calendar_df)}, Earnings={len(earnings_data)}")
 logger.info(f"Availability: Predictions={PREDICTIONS_AVAILABLE}, Sectoral={SECTORAL_AVAILABLE}, Events={EVENTS_AVAILABLE}, Calendar={CALENDAR_AVAILABLE}")
 if fetch_errors:
     for err in fetch_errors:
@@ -770,7 +800,7 @@ with col4:
 st.markdown("---")
 st.markdown("## 📊 Market Intelligence - Predictions, Sectors & Events")
 
-col5, col6, col7 = st.columns(3)
+col5, col6, col7, col8 = st.columns(4)
 
 with col5:
     # Prediction Markets Column
@@ -850,6 +880,10 @@ with col7:
         </style>
         """, unsafe_allow_html=True)
 
+with col8:
+    # Earnings Calendar Column
+    display_earnings_calendar(earnings_data, height="600px")
+
 # Display fetch errors in expander (less intrusive)
 if 'fetch_errors' in locals() and fetch_errors:
     with st.expander("⚠️ Source Fetch Warnings", expanded=False):

app/services/earnings_calendar.py

@@ -0,0 +1,214 @@
+"""
+Earnings Calendar Service
+Primary:  Alpha Vantage EARNINGS_CALENDAR (free, CSV, uses ALPHA_VANTAGE_KEY or demo key)
+Fallback: StockAnalysis.com JSON scraping
+"""
+
+import csv
+import io
+import json
+import logging
+import re
+from datetime import datetime, timedelta
+from typing import List, Dict, Optional
+
+import requests
+from bs4 import BeautifulSoup
+
+logger = logging.getLogger(__name__)
+
+# Top companies to highlight (filter from the full calendar)
+TOP_TICKERS = {
+    "AAPL", "MSFT", "NVDA", "AMZN", "GOOGL", "GOOG", "META", "TSLA",
+    "AVGO", "JPM", "LLY", "V", "MA", "UNH", "XOM", "COST", "HD",
+    "WMT", "PG", "NFLX", "BAC", "ORCL", "CRM", "AMD", "INTC", "QCOM",
+    "GS", "MS", "CVX", "ABBV", "MRK", "BRK-B", "BRKB", "KO", "PEP",
+    "DIS", "PYPL", "ADBE", "CSCO", "TXN", "HON", "RTX", "CAT", "IBM",
+}
+
+
+class EarningsCalendarService:
+    """Fetches upcoming earnings report dates without mock data."""
+
+    ALPHA_VANTAGE_URL = (
+        "https://www.alphavantage.co/query"
+        "?function=EARNINGS_CALENDAR&horizon=3month&apikey={api_key}"
+    )
+    STOCKANALYSIS_URL = "https://stockanalysis.com/stocks/earnings-calendar/"
+
+    def __init__(self, api_key: Optional[str] = None):
+        self.api_key = api_key or "demo"
+        self.session = requests.Session()
+        self.session.headers.update({
+            "User-Agent": (
+                "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) "
+                "AppleWebKit/537.36 (KHTML, like Gecko) "
+                "Chrome/120.0.0.0 Safari/537.36"
+            ),
+            "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+            "Accept-Language": "en-US,en;q=0.9",
+        })
+
+    def get_upcoming_earnings(self, days_ahead: int = 30) -> List[Dict]:
+        """
+        Returns upcoming earnings entries sorted by date.
+        Each entry: {ticker, company, date, days_until, report_time, eps_estimate}
+        """
+        entries = self._fetch_alpha_vantage(days_ahead)
+        if not entries:
+            logger.warning("Alpha Vantage returned no data, trying StockAnalysis fallback")
+            entries = self._fetch_stockanalysis(days_ahead)
+        return entries
+
+    # ------------------------------------------------------------------
+    # Primary: Alpha Vantage
+    # ------------------------------------------------------------------
+
+    def _fetch_alpha_vantage(self, days_ahead: int) -> List[Dict]:
+        try:
+            url = self.ALPHA_VANTAGE_URL.format(api_key=self.api_key)
+            resp = self.session.get(url, timeout=15)
+            resp.raise_for_status()
+
+            # Alpha Vantage returns CSV for this endpoint
+            content = resp.text
+            if not content or "symbol" not in content[:200].lower():
+                logger.warning("Alpha Vantage response doesn't look like CSV")
+                return []
+
+            reader = csv.DictReader(io.StringIO(content))
+            now = datetime.now()
+            cutoff = now + timedelta(days=days_ahead)
+            entries = []
+
+            for row in reader:
+                try:
+                    ticker = (row.get("symbol") or "").strip().upper()
+                    if not ticker:
+                        continue
+
+                    # Filter to top companies only
+                    if ticker not in TOP_TICKERS:
+                        continue
+
+                    date_str = (row.get("reportDate") or "").strip()
+                    if not date_str:
+                        continue
+                    date = datetime.strptime(date_str, "%Y-%m-%d")
+
+                    if date < now - timedelta(days=1) or date > cutoff:
+                        continue
+
+                    days_until = (date.date() - now.date()).days
+
+                    eps_str = (row.get("estimate") or "").strip()
+                    eps_estimate = float(eps_str) if eps_str and eps_str != "-" else None
+
+                    fiscal_end = (row.get("fiscalDateEnding") or "").strip()
+                    currency = (row.get("currency") or "USD").strip()
+
+                    entries.append({
+                        "ticker": ticker,
+                        "company": row.get("name", ticker).strip(),
+                        "date": date,
+                        "days_until": days_until,
+                        "report_time": None,          # AV doesn't provide BMO/AMC
+                        "eps_estimate": eps_estimate,
+                        "fiscal_end": fiscal_end,
+                        "currency": currency,
+                        "source": "Alpha Vantage",
+                    })
+
+                except (ValueError, KeyError) as e:
+                    logger.debug(f"Skipping AV row: {e}")
+                    continue
+
+            entries.sort(key=lambda x: x["date"])
+            logger.info(f"Alpha Vantage: {len(entries)} top-company earnings fetched")
+            return entries
+
+        except Exception as e:
+            logger.error(f"Alpha Vantage earnings fetch failed: {e}")
+            return []
+
+    # ------------------------------------------------------------------
+    # Fallback: StockAnalysis.com
+    # ------------------------------------------------------------------
+
+    def _fetch_stockanalysis(self, days_ahead: int) -> List[Dict]:
+        try:
+            resp = self.session.get(self.STOCKANALYSIS_URL, timeout=15)
+            resp.raise_for_status()
+
+            soup = BeautifulSoup(resp.text, "html.parser")
+
+            # StockAnalysis embeds earnings data as JSON in a <script> tag
+            script_tag = soup.find("script", string=re.compile(r'"earningsCalendar"'))
+            if not script_tag:
+                for tag in soup.find_all("script", type="application/json"):
+                    text = tag.get_text() or ""
+                    if "earningsCalendar" in text:
+                        script_tag = tag
+                        break
+
+            if not script_tag:
+                logger.warning("StockAnalysis: could not locate earnings JSON")
+                return []
+
+            # Extract JSON blob
+            raw = script_tag.get_text() or ""
+            match = re.search(r'"earningsCalendar"\s*:\s*(\[.*?\])', raw, re.DOTALL)
+            if not match:
+                logger.warning("StockAnalysis: earnings JSON pattern not found")
+                return []
+
+            data = json.loads(match.group(1))
+
+            now = datetime.now()
+            cutoff = now + timedelta(days=days_ahead)
+            entries = []
+
+            for week in data:
+                date_str = week.get("date") or week.get("week", "")
+                try:
+                    date = datetime.strptime(date_str[:10], "%Y-%m-%d")
+                except ValueError:
+                    continue
+
+                if date < now - timedelta(days=1) or date > cutoff:
+                    continue
+
+                days_until = (date.date() - now.date()).days
+
+                for item in week.get("stocks", []):
+                    ticker = (item.get("s") or "").upper()
+                    if ticker not in TOP_TICKERS:
+                        continue
+
+                    report_time_raw = item.get("t", "")
+                    report_time = (
+                        "BMO" if report_time_raw == "bmo"
+                        else "AMC" if report_time_raw == "amc"
+                        else None
+                    )
+                    eps_est = item.get("e")
+
+                    entries.append({
+                        "ticker": ticker,
+                        "company": item.get("n", ticker),
+                        "date": date,
+                        "days_until": days_until,
+                        "report_time": report_time,
+                        "eps_estimate": float(eps_est) if eps_est is not None else None,
+                        "fiscal_end": None,
+                        "currency": "USD",
+                        "source": "StockAnalysis",
+                    })
+
+            entries.sort(key=lambda x: x["date"])
+            logger.info(f"StockAnalysis: {len(entries)} earnings fetched")
+            return entries
+
+        except Exception as e:
+            logger.error(f"StockAnalysis earnings fetch failed: {e}")
+            return []

requirements.txt

@@ -11,3 +11,4 @@ lxml>=5.0.0
 ntscraper
 playwright>=1.40.0
 huggingface_hub>=0.22.2
+yfinance>=0.2.0