Overview

The Finance App is an interactive Streamlit-based web application that enables users to analyze stock performance, calculate key financial metrics, and optimize portfolio allocations. The app fetches real-time stock data from Yahoo Finance and provides intuitive visualizations for investment decision-making.

Features

Stock Data Analysis

  • Multi-ticker Support: Analyze multiple stocks simultaneously with comma-separated inputs
  • Flexible Date Range: Select custom date ranges for historical analysis
  • Real-time Data: Fetch current stock data through Yahoo Finance API
  • Price Visualization: Interactive charts showing price movements over time
  • Returns Analysis: Visualize and analyze stock return patterns
  • Data Export: Download stock data as CSV for further analysis

Performance Metrics

  • Sharpe Ratio: Calculate risk-adjusted returns to measure performance efficiency
  • Sortino Ratio: Evaluate downside risk-adjusted performance
  • Maximum Drawdown: Measure the largest peak-to-trough decline
  • Value at Risk (VaR): Statistical measure of potential loss at a given confidence level
  • Annualized Volatility: Measure of price fluctuation scaled to annual basis
  • Comparative Analysis: Compare performance across multiple securities

Portfolio Management

  • Portfolio Optimization: Generate optimal portfolio weights using mean-variance optimization
  • Risk Minimization: Find allocations that reduce portfolio volatility
  • Weight Visualization: Bar charts showing allocation across different securities
  • Equal-Weight Option: Simple equal-weighted portfolio allocation
  • Interactive Interface: User-friendly controls for customizing analysis parameters

Strategy Backtesting

  • Moving Average Crossover: Test simple technical trading strategies
  • Signal Visualization: Visual indicators for buy and sell signals
  • Performance Evaluation: Assess strategy effectiveness against benchmarks
  • Custom Parameter Adjustment: Modify strategy parameters to optimize results

Report Generation

  • PDF Reports: Create downloadable financial analysis reports
  • Key Metrics Summary: Consolidated view of important performance indicators
  • Professional Formatting: Clean presentation of financial data

Technical Implementation

Core Data Fetching

def fetch_data(tickers, start_date, end_date):
    data_frames = []
    for ticker in tickers:
        stock_data = yf.download(ticker, start=start_date, end=end_date)['Adj Close']
        data_frames.append(stock_data)
    
    data = pd.concat(data_frames, axis=1, keys=tickers)
    data.columns = tickers
    return data

The application fetches adjusted close prices using the Yahoo Finance API, processes the data with Pandas, and presents it through multiple interactive visualizations.

Performance Calculations

def calculate_sharpe_ratio(returns, risk_free_rate=0.02):
    # Calculate Sharpe ratio for the portfolio
    portfolio_return = returns.mean().mean()
    portfolio_volatility = returns.std().mean()
    return (portfolio_return - risk_free_rate) / portfolio_volatility

def calculate_sortino_ratio(returns, risk_free_rate=0.02):
    # Calculate Sortino ratio for the portfolio
    portfolio_return = returns.mean().mean()
    downside_returns = returns[returns < 0]
    downside_deviation = downside_returns.std().mean()
    return (portfolio_return - risk_free_rate) / downside_deviation

def calculate_max_drawdown(returns):
    # Calculate maximum drawdown
    cumulative_returns = (1 + returns).cumprod()
    drawdowns = cumulative_returns / cumulative_returns.cummax() - 1
    return drawdowns.min()

def calculate_var(returns, confidence_level=0.95):
    # Calculate Value at Risk (VaR) at a given confidence level
    return np.percentile(returns, (1 - confidence_level) * 100)

These implementations calculate crucial risk-adjusted performance metrics that help users understand investment efficiency and risk.

Advanced Portfolio Optimization

def portfolio_optimization(returns):
    mean_returns = returns.mean()
    cov_matrix = returns.cov()

    num_assets = len(mean_returns)
    initial_weights = np.ones(num_assets) / num_assets

    # Objective function for portfolio volatility
    def objective(weights):
        return np.sqrt(np.dot(weights.T, np.dot(cov_matrix, weights)))

    # Constraints (weights sum to 1)
    constraints = ({'type': 'eq', 'fun': lambda weights: np.sum(weights) - 1})

    # Bounds for each weight (no short-selling)
    bounds = tuple((0, 1) for _ in range(num_assets))

    # Minimize portfolio volatility
    result = minimize(objective, initial_weights, bounds=bounds, constraints=constraints)
    return result.x

This implementation uses SciPy’s optimization tools to find the minimum volatility portfolio allocation, providing users with mathematically optimal investment weights.

Strategy Backtesting

def backtest_strategy(data, short_window=50, long_window=200):
    signals = pd.DataFrame(index=data.index)
    signals['price'] = data['AAPL']  # Use any stock data
    signals['short_mavg'] = data['AAPL'].rolling(window=short_window, min_periods=1, center=False).mean()
    signals['long_mavg'] = data['AAPL'].rolling(window=long_window, min_periods=1, center=False).mean()
    
    signals['signal'] = 0.0
    signals['signal'][short_window:] = np.where(signals['short_mavg'][short_window:] > signals['long_mavg'][short_window:], 1.0, 0.0)
    signals['positions'] = signals['signal'].diff()
    
    # Visualization and return signals data
    return signals

This function implements a simple moving average crossover strategy and visualizes buy/sell signals, providing a foundation for strategy backtesting.

User Interface

The Streamlit interface provides:

  • Text inputs for stock ticker entry
  • Date selectors for time range customization
  • Interactive charts for price and returns visualization
  • Performance metrics display
  • Portfolio weight visualization
  • Data download capabilities
  • Strategy visualization options

Technology Stack

  • Streamlit: Powers the interactive web interface
  • Pandas: Handles financial data processing
  • yfinance: Provides stock market data access
  • NumPy: Performs numerical operations
  • Matplotlib: Creates financial charts and visualizations
  • SciPy: Implements optimization algorithms for portfolio allocation
  • ReportLab: Generates PDF reports with financial analysis
  • Jupyter Notebook: Supports research and development workflow

Future Enhancements

Planned improvements include:

  • Advanced portfolio optimization using Modern Portfolio Theory
  • Additional performance metrics (Jensen’s Alpha, Information Ratio)
  • Technical indicator integration (RSI, MACD, Bollinger Bands)
  • Fundamental analysis using financial statement data
  • Machine learning for return prediction and anomaly detection
  • Monte Carlo simulations for risk assessment
  • Custom strategy builder interface