fix portfolio calculator

portfolio_calculator.py

@@ -31,6 +31,10 @@ def fetch_historical_data(
     """
     Fetch historical price data using yfinance.
 
+    Uses fallback strategy:
+    1. Try downloading all tickers together
+    2. If that fails, download one by one and combine
+
     Args:
         tickers: Tuple of ticker symbols (e.g., ('AAPL', 'GOOGL', 'MSFT'))
         period: Time period for historical data (default: '1y')
@@ -40,45 +44,78 @@ def fetch_historical_data(
         - If successful: (DataFrame, None)
         - If failed: (None, error_message)
     """
+    ticker_list = list(tickers)
+
+    # Strategy 1: Try downloading all tickers together
     try:
-        # Convert tuple back to list for yfinance
-        ticker_list = list(tickers)
-
-        # Download data (progress=False to avoid console output in Streamlit)
-        data = yf.download(ticker_list, period=period, progress=False)
-
-        # Check if data was returned
-        if data.empty:
-            return None, "No data returned from yfinance. Please check ticker symbols."
-
-        # Extract 'Adj Close' prices
-        if len(ticker_list) == 1:
-            # Single ticker: yfinance returns different structure
-            prices = data[['Adj Close']].copy()
-            prices.columns = ticker_list
-        else:
-            # Multiple tickers
-            prices = data['Adj Close'].copy()
-
-        # Check for missing data
-        missing_count = prices.isnull().sum()
-        if missing_count.sum() > 0:
-            missing_tickers = missing_count[missing_count > 0]
-            warning = f"Warning: Missing data detected - {dict(missing_tickers)}"
-            # Don't fail, just warn
-            st.warning(warning)
-
-        # Drop rows with NaN values
-        prices = prices.dropna()
-
-        # Check we have enough data points
-        if len(prices) < MIN_DATA_POINTS:
-            return None, f"Insufficient data: only {len(prices)} days available (minimum {MIN_DATA_POINTS} required)"
-
-        return prices, None
+        data = yf.download(
+            ticker_list,
+            period=period,
+            progress=False,
+            threads=False,  # Disable threading for better reliability
+            ignore_tz=True
+        )
+
+        if not data.empty:
+            # Extract 'Adj Close' prices
+            if len(ticker_list) == 1:
+                prices = data[['Adj Close']].copy()
+                prices.columns = ticker_list
+            else:
+                prices = data['Adj Close'].copy()
+
+            # Drop rows with NaN values
+            prices = prices.dropna()
+
+            if len(prices) >= MIN_DATA_POINTS:
+                return prices, None
 
     except Exception as e:
-        return None, f"Failed to fetch data: {str(e)}"
+        # Log the error but continue to fallback strategy
+        print(f"Batch download failed: {str(e)}, trying individual downloads...")
+
+    # Strategy 2: Download one ticker at a time
+    st.info("Fetching data individually for each ticker...")
+    individual_prices = {}
+    failed_tickers = []
+
+    for ticker in ticker_list:
+        try:
+            # Use Ticker object for more reliable downloads
+            ticker_obj = yf.Ticker(ticker)
+            hist = ticker_obj.history(period=period)
+
+            if hist.empty:
+                failed_tickers.append(ticker)
+                continue
+
+            # Extract close prices
+            individual_prices[ticker] = hist['Close']
+
+        except Exception as e:
+            failed_tickers.append(ticker)
+            print(f"Failed to fetch {ticker}: {str(e)}")
+            continue
+
+    # Check if we got any data
+    if not individual_prices:
+        return None, f"Could not fetch data for any tickers. Failed: {', '.join(failed_tickers)}"
+
+    # Combine all individual price series
+    prices_df = pd.DataFrame(individual_prices)
+
+    # Drop rows with NaN values
+    prices_df = prices_df.dropna()
+
+    # Check we have enough data points
+    if len(prices_df) < MIN_DATA_POINTS:
+        return None, f"Insufficient data: only {len(prices_df)} days available (minimum {MIN_DATA_POINTS} required)"
+
+    # Warn about failed tickers
+    if failed_tickers:
+        st.warning(f"⚠️ Could not fetch data for: {', '.join(failed_tickers)}")
+
+    return prices_df, None
 
 
 def calculate_log_returns(prices: pd.DataFrame) -> pd.DataFrame: