import yfinance as yf

def check_premium_discount(etf_ticker: str) -> dict:
    """
    Check ETF's approximate premium/discount to NAV.
    Note: Intraday NAV (iNAV) is more accurate but harder to access freely.
    """
    etf = yf.Ticker(etf_ticker)
    info = etf.info

    market_price = info.get('regularMarketPrice', None)
    nav = info.get('navPrice', None)

    if market_price and nav:
        premium_pct = (market_price - nav) / nav * 100
        return {
            'Ticker': etf_ticker,
            'Market Price': f"${market_price:.2f}",
            'NAV': f"${nav:.2f}",
            'Premium/Discount': f"{premium_pct:+.3f}%"
        }
    return {'Ticker': etf_ticker, 'Note': 'NAV not available via yfinance'}

import numpy as np
import pandas as pd

def expense_ratio_drag(
    investment: float,
    gross_return: float,    # Annual return before fees (e.g., 0.10 for 10%)
    years: int,
    expense_ratios: list    # e.g., [0.0003, 0.0007, 0.0020, 0.0075]
) -> pd.DataFrame:
    """
    Show the compounded cost of different expense ratios over time.
    """
    rows = []
    for er in expense_ratios:
        net_return = gross_return - er
        final_value = investment * (1 + net_return) ** years
        gross_value = investment * (1 + gross_return) ** years
        cost = gross_value - final_value

        rows.append({
            'Expense Ratio': f"{er:.2%}",
            'Net Annual Return': f"{net_return:.2%}",
            f'Value after {years}yr': f"${final_value:,.0f}",
            'Cost vs. No-Fee': f"${cost:,.0f}",
            'Cost %': f"{cost / gross_value:.1%}",
        })

    df = pd.DataFrame(rows)
    print(f"\nExpense Ratio Impact: ${investment:,.0f} invested, {gross_return:.0%} gross return, {years} years\n")
    print(df.to_string(index=False))
    return df


expense_ratio_drag(
    investment=100_000,
    gross_return=0.10,
    years=30,
    expense_ratios=[0.0003, 0.0006, 0.0020, 0.0050, 0.0075, 0.0100]
)

# Output (approximate):
# ER 0.03% → $1,742k (cost: $5k)
# ER 0.06% → $1,724k (cost: $23k)
# ER 0.20% → $1,607k (cost: $140k)
# ER 0.50% → $1,433k (cost: $314k)
# ER 0.75% → $1,308k (cost: $439k)
# ER 1.00% → $1,193k (cost: $554k)

import yfinance as yf
import pandas as pd

def calculate_tracking_difference(etf: str, benchmark: str,
                                   start: str = '2020-01-01') -> dict:
    """
    Estimate tracking difference between an ETF and its benchmark proxy.

    Args:
        etf: ETF ticker (e.g., 'VTI')
        benchmark: Benchmark proxy ticker (e.g., '^VTI' or related index ETF)

    Note: True tracking difference requires the actual index return, which
    is only available from fund providers. This uses a comparable ETF as proxy.
    """
    data = yf.download([etf, benchmark], start=start, auto_adjust=True)['Close']
    returns = data.pct_change().dropna()

    etf_annual = (1 + returns[etf]).prod() ** (252 / len(returns)) - 1
    bmark_annual = (1 + returns[benchmark]).prod() ** (252 / len(returns)) - 1

    tracking_diff = etf_annual - bmark_annual
    tracking_error = (returns[etf] - returns[benchmark]).std() * (252 ** 0.5)

    return {
        'ETF': etf,
        'Benchmark Proxy': benchmark,
        'ETF Annual Return': f"{etf_annual:.3%}",
        'Benchmark Annual Return': f"{bmark_annual:.3%}",
        'Tracking Difference': f"{tracking_diff:+.3%}",
        'Tracking Error (Ann.)': f"{tracking_error:.3%}",
        'Period': f"{start} to {returns.index[-1].date()}",
    }

# Compare two S&P 500 ETFs (VOO vs. IVV as proxies for each other)
print(calculate_tracking_difference('VOO', 'IVV', start='2015-01-01'))

# Compare total market ETFs
print(calculate_tracking_difference('VTI', 'ITOT', start='2015-01-01'))

import yfinance as yf

def check_capital_gains_history(tickers: list) -> pd.DataFrame:
    """
    Check capital gains distribution history.
    Note: yfinance combines dividends and capital gains in .dividends
    For accurate CG data, check fund provider websites or Morningstar.
    """
    # Practical approach: check dividend yield relative to category
    results = []
    for ticker in tickers:
        info = yf.Ticker(ticker).info
        results.append({
            'ETF': ticker,
            'Fund Type': info.get('quoteType', 'N/A'),
            'Structure': info.get('fundInceptionDate', 'N/A'),
            'Dividend Yield': f"{info.get('dividendYield', 0) * 100:.2f}%",
            'Tax Note': 'Verify capital gains at fund provider website'
        })
    return pd.DataFrame(results)

# For actual capital gains history, use:
# - Vanguard: personal.vanguard.com → Tax center
# - iShares: ishares.com → Tax information
# - Schwab: schwabfunds.com → Tax information

import yfinance as yf

def liquidity_assessment(tickers: list) -> pd.DataFrame:
    """Assess ETF liquidity metrics."""
    results = []
    for ticker in tickers:
        info = yf.Ticker(ticker).info
        aum = info.get('totalAssets', 0)
        avg_volume = info.get('averageVolume', 0)
        price = info.get('regularMarketPrice', 1)

        # Estimate daily dollar volume
        daily_dollar_vol = avg_volume * price

        # Rough bid-ask estimate (yfinance doesn't provide real-time spread)
        # For actual spread: check Bloomberg, Morningstar, or broker platform
        liquidity_tier = (
            'Excellent' if aum > 5e9 else
            'Good' if aum > 1e9 else
            'Adequate' if aum > 500e6 else
            'Caution' if aum > 100e6 else
            'High Risk of Closure'
        )

        results.append({
            'ETF': ticker,
            'AUM': f"${aum/1e9:.1f}B" if aum > 1e9 else f"${aum/1e6:.0f}M",
            'Avg Daily Volume': f"{avg_volume:,.0f}",
            'Daily $ Volume': f"${daily_dollar_vol/1e6:.1f}M",
            'Liquidity': liquidity_tier,
        })

    return pd.DataFrame(results)

# Compare similar ETFs
print(liquidity_assessment(['VTI', 'SCHB', 'ITOT', 'SPTM']))

import yfinance as yf
import pandas as pd

def compare_etfs(tickers: list, start: str = '2015-01-01') -> pd.DataFrame:
    """
    Comprehensive ETF comparison: returns, cost, and basic structure.
    """
    price_data = yf.download(tickers, start=start, auto_adjust=True)['Close']
    returns = price_data.pct_change().dropna()

    rows = []
    for ticker in tickers:
        info = yf.Ticker(ticker).info
        r = returns[ticker].dropna()

        annual_ret = (1 + r).prod() ** (252 / len(r)) - 1
        annual_vol = r.std() * (252 ** 0.5)
        sharpe = (annual_ret - 0.05) / annual_vol  # Assume 5% risk-free (adjust to current)
        dd = ((1 + r).cumprod() / (1 + r).cumprod().cummax() - 1).min()
        er = info.get('annualReportExpenseRatio') or info.get('netExpenseRatio') or 0

        rows.append({
            'ETF': ticker,
            'Category': info.get('category', 'N/A'),
            'AUM': f"${info.get('totalAssets', 0)/1e9:.1f}B",
            'Expense Ratio': f"{(er or 0):.2%}",
            f'Ann. Return ({start[:4]}-)': f"{annual_ret:.2%}",
            'Annual Volatility': f"{annual_vol:.2%}",
            'Sharpe (5% RF)': f"{sharpe:.2f}",
            'Max Drawdown': f"{dd:.2%}",
        })

    df = pd.DataFrame(rows)
    return df


# US Total Market comparison
print(compare_etfs(['VTI', 'SCHB', 'ITOT', 'FSKAX'], start='2015-01-01'))

# Core bond comparison
print(compare_etfs(['BND', 'AGG', 'SCHZ', 'FXNAX'], start='2015-01-01'))