portfolioriskpro 2.1.0__tar.gz

portfolioriskpro-2.1.0/PKG-INFO

@@ -0,0 +1,19 @@
+Metadata-Version: 2.4
+Name: portfolioriskpro
+Version: 2.1.0
+Summary: Smart portfolio risk analysis with Efficient Frontier and LSTM forecasting
+Author: Yash
+Requires-Python: >=3.8
+Requires-Dist: PyPortfolioOpt>=1.5.0
+Requires-Dist: arch>=5.0.0
+Requires-Dist: numpy>=1.21.0
+Requires-Dist: pandas>=1.3.0
+Requires-Dist: scipy>=1.7.0
+Requires-Dist: yfinance>=0.2.0
+Provides-Extra: deep
+Requires-Dist: tensorflow>=2.10.0; extra == "deep"
+Dynamic: author
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

portfolioriskpro-2.1.0/portfoliorisk/__init__.py

@@ -0,0 +1,20 @@
+"""
+portfoliorisk v2.0.0
+====================
+Quantitative portfolio risk analysis with smart allocation and deep learning.
+
+Upgrades in v2.0.0:
+  - Smart weight allocation (Efficient Frontier / Maximum Sharpe Ratio)
+  - LSTM Neural Network volatility forecasting (TensorFlow)
+
+Usage
+-----
+    import portfoliorisk as pr
+    pr.run(["AAPL", "NVDA", "JPM", "XOM", "GLD", "MSFT", "AMZN"], investment=50000)
+"""
+
+from .pipeline import run
+
+__version__ = "2.0.1"
+__author__  = "Yash"
+__all__     = ["run"]

portfolioriskpro-2.1.0/portfoliorisk/data.py

@@ -0,0 +1,32 @@
+"""
+portfoliorisk.data
+==================
+Download and pre-process historical price data.
+"""
+
+import numpy as np
+import pandas as pd
+import yfinance as yf
+
+
+def fetch_data(tickers: list, period: str = "5y"):
+    """
+    Download adjusted closing prices and compute log returns.
+
+    Returns
+    -------
+    data        : pd.DataFrame  – adjusted close prices
+    log_returns : pd.DataFrame  – daily log returns
+    """
+    data = yf.download(tickers, period=period, auto_adjust=True, progress=False)["Close"]
+    if isinstance(data, pd.Series):
+        data = data.to_frame(name=tickers[0])
+    data = data[tickers]
+    data = data.dropna()
+
+    if data.empty:
+        raise ValueError(f"No data returned for tickers: {tickers}. "
+                         "Check ticker symbols and internet connection.")
+
+    log_returns = np.log(data / data.shift(1)).dropna()
+    return data, log_returns

portfolioriskpro-2.1.0/portfoliorisk/garch.py

@@ -0,0 +1,68 @@
+"""
+portfoliorisk.garch
+===================
+GARCH(1,1) volatility modelling and forecasting.
+Returns conditional volatility series so LSTM can use it as input.
+"""
+
+import numpy as np
+import pandas as pd
+
+try:
+    from arch import arch_model
+    ARCH_AVAILABLE = True
+except ImportError:
+    ARCH_AVAILABLE = False
+
+
+def fit_garch(port_returns: pd.Series, horizon: int = 7) -> dict:
+    """
+    Fit a GARCH(1,1) model with Student-t errors to portfolio returns
+    and produce a short-term volatility forecast.
+
+    Returns
+    -------
+    dict with keys:
+        omega, alpha, beta, nu           – model parameters
+        current_vol_annualised           – current conditional vol (annualised %)
+        forecast_vols                    – array of GARCH forecast daily vols
+        conditional_vol_series           – full array of daily conditional vols (for LSTM input)
+        log_likelihood, aic, bic         – model fit statistics
+        available                        – True if arch library is installed
+    """
+    if not ARCH_AVAILABLE:
+        return {
+            "available": False,
+            "conditional_vol_series": np.array([]),
+            "note": "Install arch library: pip install arch"
+        }
+
+    scaled = port_returns * 100
+    model  = arch_model(scaled, vol="Garch", p=1, q=1, dist="t")
+    res    = model.fit(disp="off")
+
+    params    = res.params
+    forecasts = res.forecast(horizon=horizon)
+    fvol      = np.sqrt(forecasts.variance.values[-1])
+
+    current_vol_ann = float(
+        np.sqrt(res.conditional_volatility.iloc[-1] ** 2 * 252)
+    )
+
+    # Full conditional volatility series — used as LSTM training input
+    cond_vol_series = res.conditional_volatility.values / 100  # rescale back
+
+    return {
+        "available":              True,
+        "omega":                  float(params.get("omega",    np.nan)),
+        "alpha":                  float(params.get("alpha[1]", np.nan)),
+        "beta":                   float(params.get("beta[1]",  np.nan)),
+        "nu":                     float(params.get("nu",       np.nan)),
+        "current_vol_annualised": current_vol_ann,
+        "forecast_vols":          fvol.tolist(),
+        "conditional_vol_series": cond_vol_series,
+        "log_likelihood":         float(res.loglikelihood),
+        "aic":                    float(res.aic),
+        "bic":                    float(res.bic),
+        "num_observations":       int(res.nobs),
+    }

portfolioriskpro-2.1.0/portfoliorisk/montecarlo.py

@@ -0,0 +1,22 @@
+"""
+portfoliorisk.montecarlo
+========================
+Monte Carlo simulation under Normal and Student-t distributions.
+"""
+
+import numpy as np
+
+
+def run_monte_carlo(port_mean, port_std, initial_investment,
+                    num_simulations=10_000, time_horizon=252,
+                    dist="normal", df=3):
+    if dist == "normal":
+        sim_returns = np.random.normal(port_mean, port_std,
+                                       (time_horizon, num_simulations))
+    elif dist == "t":
+        sim_returns = np.random.standard_t(df=df,
+                                            size=(time_horizon, num_simulations))
+        sim_returns = sim_returns * port_std + port_mean
+    else:
+        raise ValueError(f"Unknown distribution '{dist}'.")
+    return initial_investment * np.exp(np.cumsum(sim_returns, axis=0))

portfolioriskpro-2.1.0/portfoliorisk/neural.py

@@ -0,0 +1,176 @@
+"""
+portfoliorisk.neural
+====================
+LSTM Neural Network for volatility forecasting.
+
+Combines GARCH(1,1) conditional volatility estimates with a deep learning
+LSTM model to produce more precise short-term volatility forecasts.
+
+Architecture:
+  Input  : Rolling window of GARCH conditional volatility + squared returns
+  Model  : 2-layer LSTM → Dense → output
+  Output : 7-day ahead volatility forecast
+
+Why LSTM?
+  GARCH assumes a fixed decay rate for volatility shocks. LSTM learns
+  non-linear, time-varying patterns in volatility that GARCH cannot capture —
+  such as volatility spikes around earnings, macro events, or market regimes.
+"""
+
+import numpy as np
+import warnings
+warnings.filterwarnings("ignore")
+
+try:
+    import tensorflow as tf
+    from tensorflow.keras.models import Sequential
+    from tensorflow.keras.layers import LSTM, Dense, Dropout
+    from tensorflow.keras.callbacks import EarlyStopping
+    TF_AVAILABLE = True
+except ImportError:
+    TF_AVAILABLE = False
+
+
+def _build_lstm(input_shape):
+    """Build a 2-layer LSTM model for volatility sequence prediction."""
+    model = Sequential([
+        LSTM(64, input_shape=input_shape, return_sequences=True),
+        Dropout(0.2),
+        LSTM(32, return_sequences=False),
+        Dropout(0.2),
+        Dense(16, activation="relu"),
+        Dense(1, activation="linear")
+    ])
+    model.compile(optimizer="adam", loss="mse")
+    return model
+
+
+def _make_sequences(series: np.ndarray, lookback: int = 20):
+    """
+    Convert a 1-D time series into supervised (X, y) sequences.
+    X: windows of length `lookback`, y: next value.
+    """
+    X, y = [], []
+    for i in range(lookback, len(series)):
+        X.append(series[i - lookback: i])
+        y.append(series[i])
+    return np.array(X), np.array(y)
+
+
+def forecast_with_lstm(
+    garch_conditional_vol: np.ndarray,
+    port_returns: np.ndarray,
+    horizon: int = 7,
+    lookback: int = 20,
+    epochs: int = 50,
+    batch_size: int = 32,
+) -> dict:
+    """
+    Train an LSTM on GARCH conditional volatility series and forecast
+    volatility for the next `horizon` trading days.
+
+    Parameters
+    ----------
+    garch_conditional_vol : 1-D array of GARCH daily conditional volatility
+    port_returns          : 1-D array of daily portfolio log returns
+    horizon               : number of days to forecast (default 7)
+    lookback              : LSTM sequence window length (default 20 days)
+    epochs                : training epochs (default 50)
+    batch_size            : mini-batch size (default 32)
+
+    Returns
+    -------
+    dict with keys:
+        lstm_available       : bool
+        forecast_vols        : list of horizon daily volatility forecasts (annualised %)
+        train_loss           : final training loss (MSE)
+        model_summary        : string description of the architecture
+        note                 : explanation of what was done
+    """
+    if not TF_AVAILABLE:
+        return {
+            "lstm_available": False,
+            "note": "TensorFlow not installed. Run: pip install tensorflow",
+            "forecast_vols": [],
+        }
+
+    try:
+        # ── 1. Prepare input features ──────────────────────────────────────
+        # Combine GARCH vol and squared returns as dual input signal
+        sq_returns  = np.array(port_returns) ** 2
+        garch_vol   = np.array(garch_conditional_vol)
+
+        # Align lengths
+        min_len = min(len(sq_returns), len(garch_vol))
+        sq_returns = sq_returns[-min_len:]
+        garch_vol  = garch_vol[-min_len:]
+
+        # Normalise to [0, 1] for training stability
+        vol_min, vol_max = garch_vol.min(), garch_vol.max()
+        vol_norm = (garch_vol - vol_min) / (vol_max - vol_min + 1e-8)
+
+        # ── 2. Build sequences ─────────────────────────────────────────────
+        X, y = _make_sequences(vol_norm, lookback)
+        X    = X.reshape((X.shape[0], X.shape[1], 1))  # (samples, timesteps, features)
+
+        if len(X) < 50:
+            return {
+                "lstm_available": False,
+                "note": "Insufficient data for LSTM training (need >70 observations).",
+                "forecast_vols": [],
+            }
+
+        # ── 3. Train/test split (80/20) ────────────────────────────────────
+        split   = int(len(X) * 0.8)
+        X_train, y_train = X[:split], y[:split]
+
+        # ── 4. Build and train model ───────────────────────────────────────
+        tf.random.set_seed(42)
+        model = _build_lstm((lookback, 1))
+
+        early_stop = EarlyStopping(monitor="loss", patience=5, restore_best_weights=True)
+        history    = model.fit(
+            X_train, y_train,
+            epochs=epochs,
+            batch_size=batch_size,
+            callbacks=[early_stop],
+            verbose=0
+        )
+
+        # ── 5. Autoregressive forecast ─────────────────────────────────────
+        # Start from the last `lookback` observations and predict step-by-step
+        last_seq   = vol_norm[-lookback:].copy()
+        forecasts  = []
+
+        for _ in range(horizon):
+            inp  = last_seq.reshape(1, lookback, 1)
+            pred = model.predict(inp, verbose=0)[0][0]
+            forecasts.append(float(pred))
+            last_seq = np.append(last_seq[1:], pred)
+
+        # ── 6. Denormalise forecasts back to original vol scale ────────────
+        forecasts_denorm = [v * (vol_max - vol_min) + vol_min for v in forecasts]
+
+        # Annualise: daily vol * sqrt(252) * 100 for % display
+        forecasts_annual = [v * np.sqrt(252) * 100 for v in forecasts_denorm]
+
+        train_loss = float(history.history["loss"][-1])
+
+        return {
+            "lstm_available":  True,
+            "forecast_vols":   forecasts_annual,
+            "train_loss":      train_loss,
+            "epochs_run":      len(history.history["loss"]),
+            "model_summary":   "2-layer LSTM (64→32 units) + Dropout(0.2) + Dense(16) → Dense(1)",
+            "note": (
+                "LSTM trained on GARCH conditional volatility series. "
+                "Forecasts are annualised volatility percentages."
+            ),
+        }
+
+    except Exception as e:
+        return {
+            "lstm_available": False,
+            "note": f"LSTM training failed: {str(e)}",
+            "forecast_vols": [],
+        }

portfolioriskpro-2.1.0/portfoliorisk/optimize.py

@@ -0,0 +1,63 @@
+"""
+portfoliorisk.optimize
+======================
+Smart portfolio weight allocation using Efficient Frontier (Maximum Sharpe Ratio)
+with a minimum weight constraint so every stock receives capital.
+
+Strategy:
+  - Every stock gets a guaranteed minimum floor allocation (default 5%)
+  - The remaining capital is distributed optimally using Maximum Sharpe Ratio
+  - This ensures diversification while still being data-driven
+"""
+
+import numpy as np
+from pypfopt import EfficientFrontier, risk_models, expected_returns
+
+
+def optimize_portfolio(data, risk_free_rate: float = 0.02, min_weight: float = 0.05):
+    """
+    Compute smart portfolio weights ensuring every stock receives capital.
+
+    Every asset gets at least min_weight (floor allocation).
+    The remaining weight is distributed using Maximum Sharpe Ratio optimisation.
+    This combines guaranteed diversification with data-driven intelligence.
+
+    Parameters
+    ----------
+    data           : pd.DataFrame of adjusted close prices
+    risk_free_rate : annualised risk-free rate (default 2%)
+    min_weight     : minimum allocation per stock (default 5%)
+
+    Returns
+    -------
+    weights : dict  {ticker: weight}  -- constrained optimal weights
+    perf    : tuple (expected_return, annual_volatility, sharpe_ratio)
+    """
+    n  = len(data.columns)
+    mu = expected_returns.mean_historical_return(data)
+    S  = risk_models.sample_cov(data)
+
+    # Each stock gets at least min_weight
+    # Max weight is capped so no single stock dominates
+    max_weight = max(1.0 - (n - 1) * min_weight, min_weight + 0.01)
+
+    try:
+        ef      = EfficientFrontier(mu, S, weight_bounds=(min_weight, max_weight))
+        ef.max_sharpe(risk_free_rate=risk_free_rate)
+        weights = dict(ef.clean_weights())
+        perf    = ef.portfolio_performance(verbose=False, risk_free_rate=risk_free_rate)
+    except Exception:
+        # Fallback to equal weights if constrained optimisation fails
+        equal_w = round(1.0 / n, 6)
+        weights = {t: equal_w for t in data.columns}
+        w_arr   = np.array([equal_w] * n)
+        ann_ret = float((mu.values * w_arr).sum())
+        ann_vol = float(np.sqrt(np.dot(w_arr.T, np.dot(S.values, w_arr))))
+        sharpe  = (ann_ret - risk_free_rate) / ann_vol if ann_vol > 0 else 0.0
+        perf    = (ann_ret, ann_vol, sharpe)
+
+    # Normalise so weights sum exactly to 1.0
+    total   = sum(weights.values())
+    weights = {t: round(w / total, 6) for t, w in weights.items()}
+
+    return weights, perf

portfolioriskpro-2.1.0/portfoliorisk/pipeline.py

@@ -0,0 +1,152 @@
+"""
+portfoliorisk.pipeline
+======================
+Full risk analysis pipeline — smart weights + LSTM neural network.
+
+Two major upgrades over v1.0.x:
+  1. Smart weight allocation  — Efficient Frontier (Maximum Sharpe Ratio)
+     instead of naive equal weighting. The optimizer studies historical
+     return, volatility, and correlations to find the best allocation.
+
+  2. LSTM volatility forecast  — A 2-layer LSTM neural network is trained
+     on the GARCH conditional volatility series to produce a more precise
+     7-day ahead forecast that captures non-linear volatility patterns.
+"""
+
+import numpy as np
+import warnings
+warnings.filterwarnings("ignore")
+
+from .data       import fetch_data
+from .optimize   import optimize_portfolio
+from .montecarlo import run_monte_carlo
+from .risk       import compute_var_cvar, compute_max_drawdown
+from .garch      import fit_garch
+from .neural     import forecast_with_lstm
+from .stress     import run_stress_tests
+from .report     import print_report
+
+
+def run(tickers: list, investment: float = 10_000):
+    """
+    Run the complete portfolio risk analysis pipeline and print a report.
+
+    Parameters
+    ----------
+    tickers    : list of ticker symbols, e.g. ['AAPL', 'JPM', 'XOM', 'GLD']
+    investment : total investment amount in USD (default $10,000)
+
+    Returns
+    -------
+    dict with all computed results
+
+    Example
+    -------
+    >>> import portfoliorisk as pr
+    >>> pr.run(['AAPL', 'NVDA', 'JPM', 'XOM', 'GLD', 'MSFT', 'AMZN'], investment=50000)
+    """
+    # ── Validate inputs ────────────────────────────────────────────────────
+    if not isinstance(tickers, list) or len(tickers) < 2:
+        raise ValueError(
+            "Please provide at least 2 ticker symbols as a list.\n"
+            "  Example: pr.run(['AAPL', 'TSLA', 'GLD'], investment=10000)"
+        )
+    if investment <= 0:
+        raise ValueError("Investment amount must be a positive number.")
+
+    tickers = [t.upper().strip() for t in tickers]
+
+    # ── Fixed internal settings ────────────────────────────────────────────
+    PERIOD           = "5y"
+    NUM_SIMULATIONS  = 10_000
+    TIME_HORIZON     = 252
+    CONFIDENCE       = 0.95
+    T_DF             = 3
+    RISK_FREE_RATE   = 0.02
+    RANDOM_SEED      = 42
+    STRESS_SCENARIOS = {
+        "2008 Financial Crisis  (-35%)": -0.35,
+        "Tech Sector Meltdown   (-20%)": -0.20,
+        "Interest Rate Hike     (-10%)": -0.10,
+    }
+
+    np.random.seed(RANDOM_SEED)
+
+    # ── 1. Fetch data ──────────────────────────────────────────────────────
+    print("  [1/7] Downloading market data...")
+    data, log_returns = fetch_data(tickers, PERIOD)
+
+    # ── 2. Smart weight optimisation (Efficient Frontier) ─────────────────
+    print("  [2/7] Optimising portfolio weights (Efficient Frontier)...")
+    weights, perf = optimize_portfolio(data, RISK_FREE_RATE)
+
+    # ── 3. Portfolio daily return series ──────────────────────────────────
+    w_arr        = np.array([weights[t] for t in tickers])
+    port_returns = log_returns.dot(w_arr)
+    port_mean    = port_returns.mean()
+    port_std     = port_returns.std()
+
+    # ── 4. Monte Carlo — Normal ────────────────────────────────────────────
+    print("  [3/7] Running Monte Carlo simulations (Normal)...")
+    paths_normal  = run_monte_carlo(port_mean, port_std, investment,
+                                    NUM_SIMULATIONS, TIME_HORIZON, dist="normal")
+    var_n, cvar_n = compute_var_cvar(paths_normal[-1], investment, CONFIDENCE)
+
+    # ── 5. Monte Carlo — Fat Tail ──────────────────────────────────────────
+    print("  [4/7] Running Monte Carlo simulations (Fat-Tail)...")
+    paths_fat     = run_monte_carlo(port_mean, port_std, investment,
+                                    NUM_SIMULATIONS, TIME_HORIZON, dist="t", df=T_DF)
+    var_f, cvar_f = compute_var_cvar(paths_fat[-1], investment, CONFIDENCE)
+
+    # ── 6. Max Drawdown ────────────────────────────────────────────────────
+    mdd = compute_max_drawdown(port_returns)
+
+    # ── 7. GARCH — fit and get conditional vol series ──────────────────────
+    print("  [5/7] Fitting GARCH(1,1) volatility model...")
+    garch_res = fit_garch(port_returns)
+
+    # ── 8. LSTM Neural Network forecast ───────────────────────────────────
+    print("  [6/7] Training LSTM neural network for volatility forecast...")
+    lstm_res = {"lstm_available": False, "note": "GARCH unavailable", "forecast_vols": []}
+    if garch_res.get("available") and len(garch_res.get("conditional_vol_series", [])) > 0:
+        lstm_res = forecast_with_lstm(
+            garch_conditional_vol = garch_res["conditional_vol_series"],
+            port_returns          = port_returns.values,
+            horizon               = 7,
+            lookback              = 20,
+            epochs                = 50,
+            batch_size            = 32,
+        )
+
+    # ── 9. Stress Tests ────────────────────────────────────────────────────
+    print("  [7/7] Running stress tests...")
+    stress_res = run_stress_tests(investment, STRESS_SCENARIOS)
+
+    # ── 10. Pack results ───────────────────────────────────────────────────
+    results = {
+        "tickers":            tickers,
+        "period":             PERIOD,
+        "observations":       len(data),
+        "investment":         investment,
+        "weights":            weights,
+        "weight_method":      "Efficient Frontier (Maximum Sharpe Ratio)",
+        "expected_return":    perf[0],
+        "annual_volatility":  perf[1],
+        "sharpe_ratio":       perf[2],
+        "var_normal":         var_n,
+        "cvar_normal":        cvar_n,
+        "var_fattail":        var_f,
+        "cvar_fattail":       cvar_f,
+        "max_drawdown":       mdd,
+        "garch":              garch_res,
+        "lstm":               lstm_res,
+        "stress":             stress_res,
+        "confidence":         CONFIDENCE,
+        "t_df":               T_DF,
+        "num_simulations":    NUM_SIMULATIONS,
+        "time_horizon":       TIME_HORIZON,
+    }
+
+    # ── 11. Print report ───────────────────────────────────────────────────
+    print_report(results)
+    return results

portfolioriskpro-2.1.0/portfoliorisk/report.py

@@ -0,0 +1,230 @@
+"""
+portfoliorisk.report
+====================
+Terminal report printer — includes smart weights and LSTM forecast section.
+"""
+
+from datetime import datetime
+
+
+class C:
+    RESET    = "\033[0m";  BOLD   = "\033[1m";  DIM   = "\033[2m"
+    BLUE     = "\033[34m"; CYAN   = "\033[36m";  GREEN = "\033[32m"
+    YELLOW   = "\033[33m"; RED    = "\033[31m";  WHITE = "\033[97m"
+    BG_BLUE  = "\033[44m"; BG_DARK= "\033[100m"; BG_GREEN="\033[42m"
+    BG_RED   = "\033[41m"
+
+W = 72
+
+def _line(char="─", color=C.DIM):  print(f"{color}{char*W}{C.RESET}")
+def _header(text, bg=C.BG_BLUE):
+    pad = W - len(text) - 2; l, r = pad//2, pad - pad//2
+    print(f"{bg}{C.WHITE}{C.BOLD} {'─'*l} {text} {'─'*r} {C.RESET}")
+def _section(text):
+    print(); print(f"{C.CYAN}{C.BOLD}  ▌ {text}{C.RESET}"); _line()
+def _row(label, value, color=C.WHITE, indent=4):
+    dots = "." * (W - indent - len(label) - len(str(value)) - 2)
+    print(f"{' '*indent}{C.DIM}{label} {dots}{C.RESET} {color}{C.BOLD}{value}{C.RESET}")
+def _bullet(label, value, good=True):
+    icon = f"{C.GREEN}●{C.RESET}" if good else f"{C.RED}●{C.RESET}"
+    print(f"    {icon}  {C.DIM}{label}:{C.RESET}  {C.WHITE}{C.BOLD}{value}{C.RESET}")
+def _verdict(positive, good_msg, bad_msg):
+    print()
+    if positive:
+        print(f"  {C.BG_GREEN}{C.WHITE}{C.BOLD}  VERDICT : {good_msg}  {C.RESET}")
+    else:
+        print(f"  {C.BG_RED}{C.WHITE}{C.BOLD}  VERDICT : {bad_msg}  {C.RESET}")
+    print()
+
+
+def print_report(r: dict):
+    now      = datetime.now().strftime("%Y-%m-%d  %H:%M:%S")
+    inv      = r["investment"]
+    conf_pct = int(r["confidence"] * 100)
+    g        = r["garch"]
+    lstm     = r.get("lstm", {})
+
+    print()
+    _header("  PORTFOLIORISK  ·  FULL RISK ANALYSIS REPORT  ", C.BG_BLUE)
+    print(f"  {C.DIM}Generated : {now}   |   Tickers : {', '.join(r['tickers'])}"
+          f"   |   Period : {r['period']}   |   Obs : {r['observations']:,}{C.RESET}")
+    _line("=", C.BLUE)
+
+    # ── 1. Portfolio Composition ───────────────────────────────────────────
+    _section("1  PORTFOLIO COMPOSITION  (Smart Allocation — Efficient Frontier)")
+    print(f"    {C.DIM}Method: {C.WHITE}{C.BOLD}{r['weight_method']}{C.RESET}")
+    print(f"    {C.DIM}Each stock's allocation is determined by its historical return,{C.RESET}")
+    print(f"    {C.DIM}volatility, and correlation — not split equally.{C.RESET}")
+    print()
+    for ticker, w in r["weights"].items():
+        if w < 0.001:
+            # Zero-weight assets shown dimly
+            print(f"    {C.DIM}{ticker:6s}  {'░'*40}    0.00%  (optimizer excluded){C.RESET}")
+            continue
+        bar_len = int(w * 40)
+        bar     = "█" * bar_len + "░" * (40 - bar_len)
+        alloc   = inv * w
+        print(f"    {C.CYAN}{ticker:6s}{C.RESET}  {C.BLUE}{bar}{C.RESET}  "
+              f"{C.WHITE}{C.BOLD}{w*100:5.2f}%{C.RESET}  {C.DIM}${alloc:,.2f}{C.RESET}")
+
+    active = {t: w for t, w in r["weights"].items() if w >= 0.001}
+    _verdict(True,
+             f"POSITIVE - Optimizer allocated capital across {len(active)} stocks based on data-driven risk-return analysis.",
+             "NEGATIVE - Allocation failed.")
+
+    # ── 2. Optimisation Performance ───────────────────────────────────────
+    _section("2  PORTFOLIO PERFORMANCE  (Maximum Sharpe Ratio)")
+    _row("Expected Annual Return",  f"{r['expected_return']*100:.2f}%",  C.GREEN)
+    _row("Annual Volatility",       f"{r['annual_volatility']*100:.2f}%", C.YELLOW)
+    _row("Sharpe Ratio",            f"{r['sharpe_ratio']:.4f}",           C.GREEN)
+    print(f"\n    {C.DIM}A Sharpe Ratio above 1.0 means the portfolio earns more return{C.RESET}")
+    print(f"    {C.DIM}per unit of risk than a typical market benchmark (S&P 500 ≈ 0.5).{C.RESET}")
+    sharpe_good = r["sharpe_ratio"] > 1.0
+    _verdict(sharpe_good,
+             f"POSITIVE - Sharpe Ratio {r['sharpe_ratio']:.2f} is excellent. Data-driven allocation outperforms equal weighting.",
+             f"NEGATIVE - Sharpe Ratio {r['sharpe_ratio']:.2f} < 1.0. Poor risk-adjusted return. Reconsider stock selection.")
+
+    # ── 3. Monte Carlo ─────────────────────────────────────────────────────
+    _section(f"3  MONTE CARLO SIMULATION  ({r['num_simulations']:,} paths, {r['time_horizon']} days)")
+    print(f"    {C.DIM}Investment : {C.WHITE}{C.BOLD}${inv:,.2f}{C.RESET}\n")
+    print(f"    {C.BOLD}-- Normal Distribution --{C.RESET}")
+    _row(f"  {conf_pct}% VaR",   f"${r['var_normal']:,.2f}",  C.YELLOW)
+    _row(f"  {conf_pct}% CVaR",  f"${r['cvar_normal']:,.2f}", C.YELLOW)
+    pct_n = r["var_normal"] / inv * 100
+    print(f"\n    {C.DIM}Normal model: max expected 1-year loss = {C.RESET}{C.YELLOW}{C.BOLD}{pct_n:.1f}%{C.RESET}")
+    print()
+    print(f"    {C.BOLD}-- Student-t (Fat-Tail, df={r['t_df']}) --{C.RESET}")
+    _row(f"  {conf_pct}% VaR",   f"${r['var_fattail']:,.2f}",  C.RED)
+    _row(f"  {conf_pct}% CVaR",  f"${r['cvar_fattail']:,.2f}", C.RED)
+    pct_f = r["var_fattail"] / inv * 100
+    mult  = r["var_fattail"] / r["var_normal"] if r["var_normal"] else 0
+    print(f"\n    {C.DIM}Fat-tail model: realistic crash loss = {C.RESET}{C.RED}{C.BOLD}{pct_f:.1f}%{C.RESET}"
+          f"{C.DIM}  ({mult:.1f}x larger than Normal){C.RESET}")
+    mc_good = pct_f < 25
+    _verdict(mc_good,
+             f"POSITIVE - Fat-tail downside {pct_f:.1f}% is within acceptable range.",
+             f"NEGATIVE - Fat-tail downside {pct_f:.1f}% is HIGH. Add defensive assets (GLD, bonds) to hedge.")
+
+    # ── 4. Max Drawdown ────────────────────────────────────────────────────
+    _section("4  HISTORICAL MAXIMUM DRAWDOWN")
+    mdd_pct = r["max_drawdown"] * 100
+    mdd_col = C.RED if mdd_pct < -25 else C.YELLOW
+    _row("Max Historical Drawdown", f"{mdd_pct:.2f}%", mdd_col)
+    print(f"\n    {C.DIM}At worst, portfolio fell {C.RESET}{mdd_col}{C.BOLD}{abs(mdd_pct):.2f}%{C.RESET}"
+          f"{C.DIM} from its peak before recovering.{C.RESET}")
+    mdd_good = mdd_pct > -25
+    _verdict(mdd_good,
+             f"POSITIVE - Drawdown of {mdd_pct:.2f}% is manageable. Portfolio shows resilience.",
+             f"NEGATIVE - Drawdown of {mdd_pct:.2f}% is severe. Consider lower-volatility assets.")
+
+    # ── 5. GARCH ───────────────────────────────────────────────────────────
+    _section("5  GARCH(1,1) VOLATILITY MODEL  (Student-t errors)")
+    if not g.get("available"):
+        print(f"    {C.YELLOW}{g.get('note','GARCH unavailable')}{C.RESET}")
+    else:
+        persist = g["alpha"] + g["beta"]
+        _row("omega  (base variance)",       f"{g['omega']:.6f}")
+        _row("alpha  (ARCH shock term)",     f"{g['alpha']:.4f}")
+        _row("beta   (GARCH persistence)",   f"{g['beta']:.4f}")
+        _row("alpha + beta",                  f"{persist:.4f}",
+             C.GREEN if persist < 0.95 else C.RED)
+        _row("nu     (degrees of freedom)",  f"{g['nu']:.4f}")
+        _row("Current Volatility (annual)",  f"{g['current_vol_annualised']:.2f}%", C.YELLOW)
+        _row("AIC / BIC",                    f"{g['aic']:.2f}  /  {g['bic']:.2f}")
+        print(f"\n    {C.DIM}GARCH 7-Day Forecast (scaled units):{C.RESET}")
+        for i, v in enumerate(g["forecast_vols"], 1):
+            bar   = "|" * int(v * 8)
+            trend = "↗" if i == 1 else ("↘" if v < g["forecast_vols"][i-2] else "→")
+            print(f"      Day {i}:  {C.BLUE}{bar:<20}{C.RESET}  {v:.5f}  {trend}")
+        garch_good = g["current_vol_annualised"] < 20 and persist < 0.97
+        _verdict(garch_good,
+                 f"POSITIVE - Volatility {g['current_vol_annualised']:.1f}% stable. Normal market conditions.",
+                 f"NEGATIVE - Volatility ELEVATED at {g['current_vol_annualised']:.1f}%. High persistence ({persist:.4f}). Consider hedging.")
+
+    # ── 6. LSTM Neural Network ─────────────────────────────────────────────
+    _section("6  LSTM NEURAL NETWORK  (Deep Learning Volatility Forecast)")
+    if not lstm.get("lstm_available"):
+        print(f"    {C.YELLOW}LSTM: {lstm.get('note', 'Unavailable')}{C.RESET}")
+        print(f"    {C.DIM}Install TensorFlow to enable: pip install tensorflow{C.RESET}")
+    else:
+        print(f"    {C.DIM}Architecture: {lstm.get('model_summary','')}{C.RESET}")
+        print(f"    {C.DIM}Trained for {lstm.get('epochs_run', 0)} epochs  |  "
+              f"Final MSE Loss: {lstm.get('train_loss', 0):.6f}{C.RESET}")
+        print(f"\n    {C.DIM}Note: {lstm.get('note','')}{C.RESET}")
+        print()
+        print(f"    {C.BOLD}7-Day Annualised Volatility Forecast (LSTM):{C.RESET}")
+        fvols = lstm.get("forecast_vols", [])
+        if fvols:
+            for i, v in enumerate(fvols, 1):
+                bar   = "█" * int(v / 3)
+                trend = "↗" if i == 1 else ("↘" if v < fvols[i-2] else "→")
+                color = C.RED if v > 22 else (C.YELLOW if v > 17 else C.GREEN)
+                print(f"      Day {i}:  {color}{bar:<20}{C.RESET}  {color}{v:.2f}%{C.RESET}  {trend}")
+
+            avg_lstm = sum(fvols) / len(fvols)
+            garch_now = g.get("current_vol_annualised", 0) if g.get("available") else 0
+            direction = "RISING" if avg_lstm > garch_now else "FALLING"
+            dir_color = C.RED if direction == "RISING" else C.GREEN
+            print(f"\n    {C.DIM}GARCH current vol: {garch_now:.2f}%  →  "
+                  f"LSTM avg forecast: {C.RESET}{dir_color}{C.BOLD}{avg_lstm:.2f}%  ({direction}){C.RESET}")
+            lstm_good = avg_lstm < 22
+            _verdict(lstm_good,
+                     f"POSITIVE - LSTM forecasts stable volatility (~{avg_lstm:.1f}% avg). No spike expected in next 7 days.",
+                     f"NEGATIVE - LSTM forecasts ELEVATED volatility (~{avg_lstm:.1f}% avg). Risk is expected to remain high or rise.")
+
+    # ── 7. Stress Tests ────────────────────────────────────────────────────
+    _section("7  STRESS TEST RESULTS")
+    print(f"    {C.DIM}Investment : {C.WHITE}{C.BOLD}${inv:,.2f}{C.RESET}\n")
+    all_surv = True
+    for name, s in r["stress"].items():
+        severity  = C.RED if abs(s["shock"]) >= 0.25 else (C.YELLOW if abs(s["shock"]) >= 0.15 else C.GREEN)
+        survivable= s["post_value"] > inv * 0.5
+        if not survivable: all_surv = False
+        icon = "[+] SURVIVABLE" if survivable else "[-] CRITICAL"
+        print(f"    {severity}{C.BOLD}{name}{C.RESET}")
+        print(f"      Shock {s['shock']*100:+.0f}%  →  Remaining: {C.WHITE}{C.BOLD}${s['post_value']:,.0f}{C.RESET}"
+              f"   Loss: {severity}-${s['loss']:,.0f}{C.RESET}  "
+              f"{C.GREEN if survivable else C.RED}{icon}{C.RESET}")
+        print()
+    _verdict(all_surv,
+             "POSITIVE - Portfolio survives ALL stress scenarios with >50% capital intact.",
+             "NEGATIVE - Portfolio FAILS at least one scenario. Critical capital loss risk.")
+
+    # ── Executive Summary ──────────────────────────────────────────────────
+    _line("=", C.BLUE)
+    _header("  EXECUTIVE SUMMARY  ", C.BG_DARK)
+    print()
+    _bullet("Weight Method",        r["weight_method"], good=True)
+    _bullet("Expected Annual Return",f"{r['expected_return']*100:.2f}%", good=r["expected_return"]>0.10)
+    _bullet("Sharpe Ratio",         f"{r['sharpe_ratio']:.2f}  (>1.0 = excellent)", good=r["sharpe_ratio"]>1)
+    _bullet(f"{conf_pct}% VaR (Fat-Tail)",f"${r['var_fattail']:,.2f}  ({pct_f:.1f}% of portfolio)", good=pct_f<25)
+    _bullet("CVaR (Worst-Case)",    f"${r['cvar_fattail']:,.2f}", good=False)
+    _bullet("Max Drawdown",         f"{r['max_drawdown']*100:.2f}%", good=r["max_drawdown"]>-0.25)
+    if g.get("available"):
+        persist = g["alpha"] + g["beta"]
+        _bullet("GARCH Volatility",  f"{g['current_vol_annualised']:.2f}%  (annualised)", good=g["current_vol_annualised"]<20)
+        _bullet("Volatility Persist",f"{persist:.4f}  ({'normal' if persist<0.97 else 'very slow decay'})", good=persist<0.97)
+    if lstm.get("lstm_available") and lstm.get("forecast_vols"):
+        avg_lstm = sum(lstm["forecast_vols"]) / len(lstm["forecast_vols"])
+        _bullet("LSTM 7-Day Avg Forecast", f"{avg_lstm:.2f}%  annualised vol", good=avg_lstm<22)
+    _bullet("Stress Tests",         "All survivable" if all_surv else "FAILED", good=all_surv)
+
+    overall = sum([
+        r["sharpe_ratio"] > 1.0,
+        pct_f < 25,
+        r["max_drawdown"] > -0.25,
+        g.get("current_vol_annualised", 99) < 20,
+        all_surv,
+    ])
+    print()
+    if overall >= 4:
+        print(f"  {C.BG_GREEN}{C.WHITE}{C.BOLD}  [+] OVERALL : STRONG PORTFOLIO  --  {overall}/5 checks passed  {C.RESET}")
+    elif overall >= 3:
+        print(f"  {C.BG_BLUE}{C.WHITE}{C.BOLD}  [~] OVERALL : MODERATE PORTFOLIO  --  {overall}/5 checks passed  --  review flagged areas  {C.RESET}")
+    else:
+        print(f"  {C.BG_RED}{C.WHITE}{C.BOLD}  [-] OVERALL : HIGH RISK PORTFOLIO  --  {overall}/5 checks passed  --  consider rebalancing  {C.RESET}")
+
+    print()
+    _line("=", C.BLUE)
+    print(f"  {C.DIM}portfoliorisk  |  pypi.org/project/portfoliorisk  |  {now}{C.RESET}")
+    print()

portfolioriskpro-2.1.0/portfoliorisk/risk.py

@@ -0,0 +1,22 @@
+"""
+portfoliorisk.risk
+==================
+VaR, CVaR, and Maximum Drawdown calculations.
+"""
+
+import numpy as np
+import pandas as pd
+
+
+def compute_var_cvar(terminal_values, initial_investment, confidence=0.95):
+    alpha  = 1.0 - confidence
+    cutoff = np.percentile(terminal_values, alpha * 100)
+    tail   = terminal_values[terminal_values <= cutoff]
+    return initial_investment - cutoff, initial_investment - tail.mean()
+
+
+def compute_max_drawdown(port_returns: pd.Series) -> float:
+    cumulative  = (1 + port_returns).cumprod()
+    running_max = cumulative.cummax()
+    drawdown    = (cumulative - running_max) / running_max
+    return float(drawdown.min())

portfolioriskpro-2.1.0/portfoliorisk/stress.py

@@ -0,0 +1,17 @@
+"""
+portfoliorisk.stress
+====================
+Scenario-based stress testing.
+"""
+
+
+def run_stress_tests(initial_investment: float, scenarios: dict) -> dict:
+    results = {}
+    for name, shock in scenarios.items():
+        post_value = initial_investment * (1 + shock)
+        results[name] = {
+            "shock":      shock,
+            "post_value": post_value,
+            "loss":       initial_investment - post_value,
+        }
+    return results

portfolioriskpro-2.1.0/portfolioriskpro.egg-info/PKG-INFO

@@ -0,0 +1,19 @@
+Metadata-Version: 2.4
+Name: portfolioriskpro
+Version: 2.1.0
+Summary: Smart portfolio risk analysis with Efficient Frontier and LSTM forecasting
+Author: Yash
+Requires-Python: >=3.8
+Requires-Dist: PyPortfolioOpt>=1.5.0
+Requires-Dist: arch>=5.0.0
+Requires-Dist: numpy>=1.21.0
+Requires-Dist: pandas>=1.3.0
+Requires-Dist: scipy>=1.7.0
+Requires-Dist: yfinance>=0.2.0
+Provides-Extra: deep
+Requires-Dist: tensorflow>=2.10.0; extra == "deep"
+Dynamic: author
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

portfolioriskpro-2.1.0/portfolioriskpro.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+setup.py
+portfoliorisk/__init__.py
+portfoliorisk/data.py
+portfoliorisk/garch.py
+portfoliorisk/montecarlo.py
+portfoliorisk/neural.py
+portfoliorisk/optimize.py
+portfoliorisk/pipeline.py
+portfoliorisk/report.py
+portfoliorisk/risk.py
+portfoliorisk/stress.py
+portfolioriskpro.egg-info/PKG-INFO
+portfolioriskpro.egg-info/SOURCES.txt
+portfolioriskpro.egg-info/dependency_links.txt
+portfolioriskpro.egg-info/requires.txt
+portfolioriskpro.egg-info/top_level.txt

portfolioriskpro-2.1.0/portfolioriskpro.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

portfolioriskpro-2.1.0/portfolioriskpro.egg-info/requires.txt

@@ -0,0 +1,9 @@
+PyPortfolioOpt>=1.5.0
+arch>=5.0.0
+numpy>=1.21.0
+pandas>=1.3.0
+scipy>=1.7.0
+yfinance>=0.2.0
+
+[deep]
+tensorflow>=2.10.0

portfolioriskpro-2.1.0/portfolioriskpro.egg-info/top_level.txt

@@ -0,0 +1 @@
+portfoliorisk

portfolioriskpro-2.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

portfolioriskpro-2.1.0/setup.py

@@ -0,0 +1,22 @@
+
+from setuptools import setup, find_packages
+
+setup(
+    name="portfolioriskpro",
+    version="2.1.0",
+    author="Yash",
+    description="Smart portfolio risk analysis with Efficient Frontier and LSTM forecasting",
+    packages=find_packages(),
+    install_requires=[
+        "PyPortfolioOpt>=1.5.0",
+        "arch>=5.0.0",
+        "numpy>=1.21.0",
+        "pandas>=1.3.0",
+        "scipy>=1.7.0",
+        "yfinance>=0.2.0",
+    ],
+    extras_require={
+        "deep": ["tensorflow>=2.10.0"]
+    },
+    python_requires=">=3.8",
+)