Create utils.py

src/utils.py

@@ -0,0 +1,338 @@
+import streamlit as st
+import pandas as pd
+import numpy as np
+import yfinance as yf
+import cvxpy as cp
+from datetime import datetime, timedelta
+
+# ============ DATA FETCHING ============
+
+@st.cache_data(ttl=86400)  # 24 hours
+def get_nifty50_stocks():
+    """Fetch NIFTY 50 constituent stocks"""
+    return [
+        "RELIANCE.NS", "TCS.NS", "HDFCBANK.NS", "INFY.NS", "ICICIBANK.NS",
+        "HINDUNILVR.NS", "ITC.NS", "SBIN.NS", "BHARTIARTL.NS", "KOTAKBANK.NS",
+        "LT.NS", "AXISBANK.NS", "ASIANPAINT.NS", "MARUTI.NS", "SUNPHARMA.NS",
+        "TITAN.NS", "BAJFINANCE.NS", "WIPRO.NS", "ULTRACEMCO.NS", "NESTLEIND.NS",
+        "HCLTECH.NS", "POWERGRID.NS", "NTPC.NS", "TECHM.NS", "ONGC.NS",
+        "M&M.NS", "TATAMOTORS.NS", "BAJAJFINSV.NS", "TATASTEEL.NS", "ADANIPORTS.NS",
+        "COALINDIA.NS", "INDUSINDBK.NS", "DRREDDY.NS", "JSWSTEEL.NS", "CIPLA.NS",
+        "BRITANNIA.NS", "BAJAJ-AUTO.NS", "DIVISLAB.NS", "GRASIM.NS", "HINDALCO.NS",
+        "APOLLOHOSP.NS", "EICHERMOT.NS", "HEROMOTOCO.NS", "BPCL.NS", "TATACONSUM.NS",
+        "SBILIFE.NS", "UPL.NS", "ADANIENT.NS", "HDFCLIFE.NS", "SHREECEM.NS"
+    ]
+
+@st.cache_data(ttl=86400)
+def get_sector_stocks():
+    """Get sector-wise stock lists"""
+    return {
+        "Banking & Finance": [
+            "HDFCBANK.NS", "ICICIBANK.NS", "SBIN.NS", "KOTAKBANK.NS", "AXISBANK.NS",
+            "INDUSINDBK.NS", "FEDERALBNK.NS", "BAJFINANCE.NS", "BAJAJFINSV.NS", "IDFCFIRSTB.NS"
+        ],
+        "Information Technology": [
+            "TCS.NS", "INFY.NS", "HCLTECH.NS", "WIPRO.NS", "TECHM.NS",
+            "COFORGE.NS", "PERSISTENT.NS", "LTIM.NS", "MPHASIS.NS", "OFSS.NS"
+        ],
+        "FMCG & Consumer": [
+            "HINDUNILVR.NS", "ITC.NS", "NESTLEIND.NS", "BRITANNIA.NS", "DABUR.NS",
+            "GODREJCP.NS", "MARICO.NS", "TATACONSUM.NS", "UBL.NS", "COLPAL.NS"
+        ],
+        "Pharmaceuticals": [
+            "SUNPHARMA.NS", "DRREDDY.NS", "CIPLA.NS", "DIVISLAB.NS", "BIOCON.NS",
+            "LUPIN.NS", "AUROPHARMA.NS", "TORNTPHARM.NS", "ALKEM.NS", "CADILAHC.NS"
+        ],
+        "Energy & Power": [
+            "RELIANCE.NS", "ONGC.NS", "POWERGRID.NS", "NTPC.NS", "COALINDIA.NS",
+            "GAIL.NS", "IOC.NS", "BPCL.NS", "TATAPOWER.NS", "ADANIGREEN.NS"
+        ],
+        "Automobiles": [
+            "MARUTI.NS", "TATAMOTORS.NS", "M&M.NS", "BAJAJ-AUTO.NS", "EICHERMOT.NS",
+            "HEROMOTOCO.NS", "TVSMOTOR.NS", "ASHOKLEY.NS", "MRF.NS", "APOLLOTYRE.NS"
+        ],
+        "Metals & Mining": [
+            "TATASTEEL.NS", "JSWSTEEL.NS", "HINDALCO.NS", "VEDL.NS",
+            "NATIONALUM.NS", "SAIL.NS", "JINDALSTEL.NS", "NMDC.NS", "COALINDIA.NS"
+        ]
+    }
+
+@st.cache_data(ttl=1800)  # 30 minutes
+def get_stock_info(ticker):
+    """Get stock metadata"""
+    try:
+        stock = yf.Ticker(ticker)
+        info = stock.info
+        return {
+            'name': info.get('longName', ticker),
+            'sector': info.get('sector', 'Unknown'),
+            'industry': info.get('industry', 'Unknown'),
+            'price': info.get('currentPrice', 0),
+        }
+    except:
+        return {'name': ticker, 'sector': 'Unknown', 'industry': 'Unknown', 'price': 0}
+
+def download_prices(tickers, start_date, end_date):
+    """Download historical stock prices"""
+    try:
+        data = yf.download(
+            tickers, 
+            start=start_date, 
+            end=end_date, 
+            progress=False,
+            group_by="ticker" if len(tickers) > 1 else None
+        )
+        
+        if data.empty:
+            return pd.DataFrame()
+        
+        if len(tickers) == 1:
+            if 'Close' in data.columns:
+                prices = data[['Close']].copy()
+                prices.columns = tickers
+            else:
+                return pd.DataFrame()
+        elif isinstance(data.columns, pd.MultiIndex):
+            cleaned = {}
+            for ticker in tickers:
+                try:
+                    ticker_data = data[ticker]['Close'].dropna()
+                    if len(ticker_data) > 50:
+                        cleaned[ticker] = ticker_data
+                except:
+                    continue
+            prices = pd.DataFrame(cleaned)
+        else:
+            prices = data
+            
+        prices = prices.ffill().dropna(how='all').dropna(axis=1, how='all')
+        return prices
+    except Exception as e:
+        st.error(f"Error downloading data: {str(e)}")
+        return pd.DataFrame()
+
+# ============ STATISTICS & OPTIMIZATION ============
+
+def compute_portfolio_stats(prices, periods_per_year=252):
+    """Calculate portfolio statistics"""
+    returns = prices.pct_change().dropna()
+    mean_annual = returns.mean() * periods_per_year
+    cov_annual = returns.cov() * periods_per_year
+    corr_matrix = returns.corr()
+    volatility_annual = returns.std() * np.sqrt(periods_per_year)
+    return returns, mean_annual, cov_annual, corr_matrix, volatility_annual
+
+def solve_optimization(cov_annual, expected_returns, target_return=None):
+    """CVXPY portfolio optimization"""
+    n = cov_annual.shape[0]
+    w = cp.Variable(n)
+    Sigma = cov_annual.values + 1e-6 * np.eye(n)
+    
+    constraints = [cp.sum(w) == 1, w >= 0]
+    if target_return is not None:
+        mu = expected_returns.values
+        constraints.append(w.T @ mu >= target_return)
+    
+    objective = cp.quad_form(w, Sigma)
+    prob = cp.Problem(cp.Minimize(objective), constraints)
+    
+    solvers = [cp.OSQP, cp.SCS, cp.ECOS]
+    for solver in solvers:
+        try:
+            prob.solve(solver=solver, verbose=False)
+            if w.value is not None and prob.status == cp.OPTIMAL:
+                weights = np.array(w.value).flatten()
+                weights = np.maximum(weights, 0)
+                weights = weights / weights.sum()
+                return weights
+        except:
+            continue
+    return np.ones(n) / n
+
+def find_max_sharpe_portfolio(expected_returns, cov_annual, risk_free_rate=0.0654, n_points=50):
+    """Find maximum Sharpe ratio portfolio"""
+    min_ret = expected_returns.min()
+    max_ret = expected_returns.max()
+    
+    if max_ret <= min_ret:
+        return solve_optimization(cov_annual, expected_returns), []
+    
+    target_returns = np.linspace(min_ret + 0.001, max_ret - 0.001, n_points)
+    best_sharpe = -np.inf
+    best_weights = None
+    efficient_frontier = []
+    
+    for target in target_returns:
+        try:
+            weights = solve_optimization(cov_annual, expected_returns, target)
+            port_return = expected_returns.values @ weights
+            port_volatility = np.sqrt(weights.T @ cov_annual.values @ weights)
+            
+            efficient_frontier.append({
+                'return': port_return,
+                'volatility': port_volatility,
+                'sharpe': (port_return - risk_free_rate) / port_volatility if port_volatility > 0 else 0
+            })
+            
+            if port_volatility > 0:
+                sharpe = (port_return - risk_free_rate) / port_volatility
+                if sharpe > best_sharpe:
+                    best_sharpe = sharpe
+                    best_weights = weights
+        except:
+            continue
+            
+    if best_weights is None:
+        best_weights = solve_optimization(cov_annual, expected_returns)
+        
+    return best_weights, efficient_frontier
+
+# ============ RISK METRICS ============
+
+def monte_carlo_simulation(returns, weights, initial_investment, n_simulations=1000, n_days=252):
+    """Run Monte Carlo simulation"""
+    mean_returns = returns.mean()
+    cov_matrix = returns.cov()
+    portfolio_returns = []
+    
+    for _ in range(n_simulations):
+        simulated_returns = np.random.multivariate_normal(mean_returns, cov_matrix, n_days)
+        portfolio_daily_returns = simulated_returns @ weights
+        portfolio_value = initial_investment * (1 + portfolio_daily_returns).cumprod()[-1]
+        portfolio_returns.append(portfolio_value)
+    
+    return np.array(portfolio_returns)
+
+def calculate_var_cvar(returns, weights, confidence_level=0.95):
+    """Calculate Value at Risk and Conditional VaR"""
+    portfolio_returns = returns @ weights
+    var = np.percentile(portfolio_returns, (1 - confidence_level) * 100)
+    cvar = portfolio_returns[portfolio_returns <= var].mean()
+    return var, cvar
+
+def calculate_max_drawdown(prices, weights):
+    """Calculate maximum drawdown"""
+    portfolio_returns = (prices @ weights).pct_change().fillna(0)
+    portfolio_value = (1 + portfolio_returns).cumprod()
+    running_max = portfolio_value.cummax()
+    drawdown = (portfolio_value - running_max) / running_max
+    max_drawdown = drawdown.min()
+    return max_drawdown, drawdown
+
+def calculate_rolling_volatility(returns, weights, window=30):
+    """Calculate rolling volatility"""
+    portfolio_returns = returns @ weights
+    rolling_vol = portfolio_returns.rolling(window=window).std() * np.sqrt(252)
+    return rolling_vol
+
+def stress_test_scenarios(returns, weights):
+    """Run stress test scenarios"""
+    portfolio_returns = returns @ weights
+    mean = portfolio_returns.mean()
+    std = portfolio_returns.std()
+    
+    scenarios = {
+        'Market Crash (-20%)': -0.20,
+        'Moderate Decline (-10%)': -0.10,
+        'Minor Correction (-5%)': -0.05,
+        'Current Volatility': std,
+        'Volatility Spike (2x)': std * 2,
+        'Best Historical Day': portfolio_returns.max(),
+        'Worst Historical Day': portfolio_returns.min(),
+        'Mean Daily Return': mean
+    }
+    return scenarios
+
+# ============ REBALANCING ============
+
+def calculate_portfolio_metrics(prices, weights, risk_free_rate=0.0654):
+    """Calculate current portfolio metrics"""
+    returns, mean_annual, cov_annual, _, _ = compute_portfolio_stats(prices)
+    
+    port_return = mean_annual.values @ weights
+    port_volatility = np.sqrt(weights.T @ cov_annual.values @ weights)
+    sharpe_ratio = (port_return - risk_free_rate) / port_volatility if port_volatility > 0 else 0
+    
+    return {
+        'return': port_return,
+        'volatility': port_volatility,
+        'sharpe': sharpe_ratio
+    }
+
+def generate_rebalancing_actions(current_holdings, optimal_weights, latest_prices, total_value, brokerage_rate=0.0003):
+    """Generate buy/sell recommendations"""
+    actions = []
+    
+    for ticker in optimal_weights.index:
+        current_shares = current_holdings.get(ticker, {}).get('shares', 0)
+        current_value = current_shares * latest_prices[ticker]
+        current_weight = current_value / total_value if total_value > 0 else 0
+        
+        target_weight = optimal_weights[ticker]
+        target_value = target_weight * total_value
+        target_shares = int(target_value / latest_prices[ticker])
+        
+        diff_shares = target_shares - current_shares
+        diff_value = diff_shares * latest_prices[ticker]
+        
+        if abs(diff_shares) > 0:
+            action = 'BUY' if diff_shares > 0 else 'SELL'
+            cost = abs(diff_value) * brokerage_rate
+            
+            actions.append({
+                'Stock': ticker,
+                'Action': action,
+                'Shares': abs(diff_shares),
+                'Price': f"₹{latest_prices[ticker]:.2f}",
+                'Amount': f"₹{abs(diff_value):,.0f}",
+                'Cost': f"₹{cost:.2f}",
+                'Current %': f"{current_weight*100:.2f}%",
+                'Target %': f"{target_weight*100:.2f}%"
+            })
+    
+    return pd.DataFrame(actions) if actions else pd.DataFrame()
+
+# ============ MARKET INSIGHTS ============
+
+@st.cache_data(ttl=300)
+def get_nifty_data():
+    """Get NIFTY 50 index data"""
+    try:
+        nifty = yf.Ticker("^NSEI")
+        data = nifty.history(period="1mo")
+        info = nifty.info
+        return data, info
+    except Exception as e:
+        st.error(f"Error fetching NIFTY data: {str(e)}")
+        return pd.DataFrame(), {}
+
+@st.cache_data(ttl=300)
+def get_top_movers(tickers, n=10):
+    """Get top gainers and losers"""
+    data = {}
+    for ticker in tickers:
+        try:
+            stock = yf.Ticker(ticker)
+            info = stock.info
+            change_val = info.get('regularMarketChangePercent', 0)
+            if change_val is None:
+                change_val = 0
+            data[ticker] = {
+                'name': info.get('longName', ticker)[:30],
+                'price': float(info.get('currentPrice', 0)),
+                'change': float(change_val),
+                'volume': int(info.get('volume', 0))
+            }
+        except:
+            continue
+    
+    df = pd.DataFrame(data).T
+    if df.empty:
+        return pd.DataFrame(), pd.DataFrame()
+    
+    df['change'] = pd.to_numeric(df['change'], errors='coerce').fillna(0)
+    df['price'] = pd.to_numeric(df['price'], errors='coerce').fillna(0)
+    
+    gainers = df.nlargest(n, 'change')
+    losers = df.nsmallest(n, 'change')
+    return gainers, losers