Value at Risk & Risk Metrics Calculation Toolkit

import Vars
import numpy as np
import pandas as pd

# 1. Generate sample data
returns = np.random.randn(1000) * 0.02

# 2. Calculate static VaR
var_results = Vars.calculate_static_var(returns, alphas=[0.01, 0.05], method='all')
print("Static VaR Results:", var_results)

# 3. Calculate Expected Shortfall
es_results = Vars.calculate_expected_shortfall(returns, confidence_levels=[0.01, 0.05])
print("Expected Shortfall Results:", es_results)

# 4. Create time series data for dynamic VaR
dates = pd.date_range('2020-01-01', periods=1000, freq='D')
returns_series = pd.Series(np.random.randn(1000) * 0.01, index=dates)

# 5. Calculate dynamic VaR
dynamic_var = Vars.calculate_dynamic_var(returns_series, method='MA', window=60)

# 6. Visualize results
fig, ax = Vars.plot_var_scatter(returns_series, dynamic_var)
import matplotlib.pyplot as plt
plt.show()

import Vars

# Run comprehensive demo
Vars.demo()

import Vars
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

# Create realistic financial time series
np.random.seed(42)
n_periods = 1000
dates = pd.date_range('2019-01-01', periods=n_periods, freq='D')

# Simulate returns with volatility clustering (GARCH-like)
volatility = 0.01 * np.ones(n_periods)
returns = np.zeros(n_periods)

for t in range(1, n_periods):
    # Simple GARCH(1,1) volatility
    volatility[t] = 0.05 + 0.85 * volatility[t-1] + 0.1 * returns[t-1]**2
    returns[t] = np.random.randn() * np.sqrt(volatility[t])

returns_series = pd.Series(returns, index=dates)

# Create RiskMetrics instance
risk = Vars.RiskMetrics(returns_series)

# Calculate all risk metrics
results = risk.calculate_all(alpha=0.05, dynamic_var_method='ARCH',
                            split_index=pd.Timestamp('2021-06-01'))

# Generate comprehensive report
report_fig = risk.plot_report(figsize=(15, 20))

# Save report
report_fig.savefig('risk_report.png', dpi=150, bbox_inches='tight')
plt.close()

print("Risk analysis completed. Report saved as 'risk_report.png'")

import Vars
import pandas as pd
import numpy as np

# Generate historical data
dates = pd.date_range('2018-01-01', periods=1500, freq='D')
returns = pd.Series(np.random.randn(1500) * 0.015, index=dates)

# Split into training and testing
train = returns[:1000]
test = returns[1000:]

# Calculate VaR on training data
var_ma = Vars.calculate_dynamic_var(train, method='MA', window=100)
var_ewma = Vars.calculate_dynamic_var(train, method='EWMA', lambda_param=0.94)

# Extend VaR forecasts to test period (simplified approach)
# In practice, you would re-estimate models recursively

# Compare exceedence rates
def calculate_exceedence(returns, var_series, alpha=0.05):
    # Simple exceedence calculation
    exceedences = returns <= var_series
    exceedence_rate = exceedences.mean()
    expected_rate = alpha
    return exceedence_rate, expected_rate

# Print results
print("VaR Backtesting Results:")
print("-" * 40)
print(f"MA VaR exceedence rate: {calculate_exceedence(train, var_ma['5%'])[0]:.2%}")
print(f"EWMA VaR exceedence rate: {calculate_exceedence(train, var_ewma['5%'])[0]:.2%}")
print(f"Expected exceedence rate: 5.00%")

def calculate_static_var(
    returns: np.ndarray,
    alphas: Union[List[float], float] = [0.01, 0.05],
    method: str = "all",
    verbose: bool = False,
    return_fitted_params: bool = False,
) -> Union[Dict[str, np.ndarray], np.ndarray, Tuple[np.ndarray, Dict]]:
    """Calculate static Value at Risk (VaR) using different methods."""

def calculate_dynamic_var(
    returns: pd.Series,
    method: str = "EWMA",
    alphas: Union[List[float], float] = [0.01, 0.05],
    align: str = "target",
    **kwargs,
) -> pd.DataFrame:
    """Calculate dynamic Value at Risk using MA, EWMA, or ARCH models."""

def calculate_expected_shortfall(
    returns: np.ndarray,
    confidence_levels: Union[List[float], float] = [0.01, 0.05],
    method: str = "all",
    num_simulations: int = 1000000,
    verbose: bool = False,
) -> Union[Dict[str, np.ndarray], np.ndarray, str]:
    """Calculate Expected Shortfall (Conditional Value at Risk)."""

def calculate_volatility(
    returns: pd.Series,
    method: str = "MA",
    **kwargs
) -> Union[pd.Series, pd.DataFrame]:
    """Calculate volatility using MA, EWMA, or ARCH models."""

def plot_var_scatter(
    returns: Union[pd.Series, np.ndarray],
    value_at_risk: Union[pd.DataFrame, pd.Series, np.ndarray, float],
    title: Optional[str] = None,
    figsize: Tuple[int, int] = (12, 6),
    show_statistics: bool = True,
    ax=None,
) -> Tuple[Any, Any]:
    """Plot VaR scatter plot for monitoring VaR exceedences."""

def plot_distribution_fit(
    data: np.ndarray,
    bins: Optional[int] = None,
    figsize: Tuple[int, int] = (10, 6),
    show_statistics: bool = True,
    style_name: str = "seaborn-v0_8-whitegrid",
) -> Any:
    """Plot data distribution histogram with fitted distributions."""

def compare_static_var_methods(
    returns: np.ndarray,
    alphas: List[float] | float = [0.01, 0.05],
    figsize: Tuple[int, int] = (14, 5),
    ax=None,
) -> Any:
    """Compare different static VaR calculation methods."""

class RiskMetrics:
    """Unified interface for risk metrics calculation and reporting."""

    def __init__(self, returns: Union[np.ndarray, pd.Series]):
        """Initialize RiskMetrics with returns data."""

    def calculate_static_var(self, alphas: float = 0.05, method: str = "all"):
        """Calculate static Value at Risk."""

    def calculate_es(self, alphas: float = 0.05, method: str = "all"):
        """Calculate Expected Shortfall."""

    def calculate_dynamic_var(
        self,
        method: str = "EWMA",
        alphas: float = 0.05,
        align: str = "target",
        fullrange=True,
        **kwargs,
    ):
        """Calculate dynamic Value at Risk."""

    def calculate_all(
        self, alphas: float = 0.05, dynamic_var_method: str = "EWMA", **kwargs
    ):
        """Calculate all risk metrics with default settings."""

    def plot_report(self, figsize: Tuple[int, int] = (15, 25), **kwargs):
        """Generate comprehensive risk report visualization."""

def demo() -> None:
    """Run comprehensive demonstration of Vars package functionality."""

def quick_var(
    returns: np.ndarray,
    alphas: float = 0.05
) -> Dict[str, float]:
    """Quick calculation of multiple VaR methods (simplified interface)."""