voly 0.0.203__tar.gz → 0.0.205__tar.gz

{voly-0.0.203/src/voly.egg-info → voly-0.0.205}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: voly
-Version: 0.0.203
+Version: 0.0.205
 Summary: Options & volatility research package
 Author-email: Manu de Cara <manu.de.cara@gmail.com>
 License: MIT

{voly-0.0.203 → voly-0.0.205}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "voly"
-version = "0.0.203"
+version = "0.0.205"
 description = "Options & volatility research package"
 readme = "README.md"
 authors = [
@@ -60,7 +60,7 @@ line_length = 100
 multi_line_output = 3
 
 [tool.mypy]
-python_version = "0.0.203"
+python_version = "0.0.205"
 warn_return_any = true
 warn_unused_configs = true
 disallow_untyped_defs = true

{voly-0.0.203 → voly-0.0.205}/src/voly/core/charts.py

@@ -68,7 +68,7 @@ def plot_volatility_smile(x_array: np.ndarray,
 
         if not maturity_data.empty:
             # Add bid and ask IVs if available
-            for iv_type in ['mark_iv', 'bid_iv', 'ask_iv']:
+            for iv_type in ['bid_iv', 'ask_iv']:
                 if iv_type in maturity_data.columns:
                     fig.add_trace(
                         go.Scatter(

{voly-0.0.203 → voly-0.0.205}/src/voly/core/data.py

@@ -198,9 +198,11 @@ def process_option_chain(df: pd.DataFrame, currency: str) -> pd.DataFrame:
 
     # Apply extraction to create new columns
     splits = df['instrument_name'].str.split('-')
-    df['currency'] = splits.str[0]
     df['maturity_name'] = splits.str[1]
-    df['strikes'] = splits.str[2].astype(float)
+    if currency == 'XRP':
+        df['strikes'] = splits.str[2].str.replace('d', '.', regex=False).astype(float)
+    else:
+        df['strikes'] = splits.str[2].astype(float)
     df['option_type'] = splits.str[3]
 
     # Create maturity date at 8:00 AM UTC
@@ -356,7 +358,14 @@ async def fetch_option_chain(exchange: str = 'deribit',
         raise VolyError(f"Exchange '{exchange}' is not supported. Currently only 'deribit' is available.")
 
     # Get raw data
-    raw_data = await get_deribit_data(currency=currency)
+    if currency not in ['BTC', 'ETH']:
+        new_currency = 'USDC'
+        raw_data = await get_deribit_data(currency=new_currency)
+        raw_data['currency'] = raw_data['instrument_name'].str.split('-').str[0].str.split('_').str[0]
+        raw_data = raw_data[raw_data['currency'] == currency]
+    else:
+        raw_data = await get_deribit_data(currency=currency)
+        raw_data['currency'] = currency
 
     # Process data
     processed_data = process_option_chain(raw_data, currency)

voly-0.0.205/src/voly/core/fit.py

@@ -0,0 +1,352 @@
+"""
+Model fitting and calibration module for the Voly package.
+
+This module handles fitting volatility models to market data, calculating fitting statistics,
+and generating visualizations.
+"""
+
+import numpy as np
+import pandas as pd
+from typing import List, Tuple, Dict, Optional, Union, Any
+from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
+from voly.utils.logger import logger, catch_exception
+from voly.formulas import get_domain
+from voly.exceptions import VolyError
+from voly.models import SVIModel
+from concurrent.futures import ThreadPoolExecutor
+import warnings
+import time
+
+warnings.filterwarnings("ignore")
+
+
+class SVICalibrator:
+    """Handles the SVI calibration process"""
+
+    def __init__(self, option_chain, currency, num_points=2000):
+        self.option_chain = option_chain
+        self.currency = currency
+        self.s = option_chain['index_price'].iloc[0]
+        self.groups = option_chain.groupby('maturity_date')
+        self.params_dict = {}
+        self.results_data = {}
+        self.num_points = num_points
+
+        # Initialize results data template
+        self.field_names = [
+            's', 't', 'maturity_date', 'maturity_name', 'a', 'b', 'm', 'rho', 'sigma',
+            'nu', 'psi', 'p', 'c', 'nu_tilde', 'log_min_strike', 'usd_min_strike',
+            'fit_success', 'butterfly_arbitrage_free', 'calendar_arbitrage_free',
+            'rmse', 'mae', 'r2', 'max_error', 'loss', 'n_points'
+        ]
+
+        # Create empty lists for each field
+        for field in self.field_names:
+            self.results_data[field] = []
+
+    def failed_calibration(self, maturity, maturity_name, t, n_points):
+        """Create an empty result for failed calibration"""
+        return {
+            's': float(self.s),
+            't': float(t),
+            'maturity_date': maturity,
+            'maturity_name': maturity_name,
+            'fit_success': False,
+            'calendar_arbitrage_free': True,  # Updated later
+            'loss': float(np.inf),
+            'n_points': int(n_points),
+            'a': np.nan, 'b': np.nan, 'm': np.nan, 'rho': np.nan, 'sigma': np.nan,
+            'nu': np.nan, 'psi': np.nan, 'p': np.nan, 'c': np.nan, 'nu_tilde': np.nan,
+            'log_min_strike': np.nan, 'usd_min_strike': np.nan,
+            'butterfly_arbitrage_free': False,
+            'rmse': np.nan, 'mae': np.nan, 'r2': np.nan, 'max_error': np.nan
+        }
+
+    def filter_market_data(self, group):
+        """Filter and prepare market data"""
+        # Filter for call options only
+        group = group[group['option_type'] == 'C']
+
+        # Handle duplicated IVs by keeping the row closest to log_moneyness=0
+        duplicated_iv = group[group.duplicated('mark_iv', keep=False)]
+        if not duplicated_iv.empty:
+            cleaned_dupes = duplicated_iv.groupby('mark_iv').apply(
+                lambda g: g.loc[[g['log_moneyness'].abs().idxmin()]]
+            ).reset_index(drop=True)
+
+            # Combine cleaned duplicates with unique rows
+            unique_iv = group.drop_duplicates('mark_iv', keep=False)
+            group = pd.concat([unique_iv, cleaned_dupes])
+
+        # Extract basic data
+        maturity_name = group['maturity_name'].iloc[0]
+        t = group['t'].iloc[0]
+        K = group['strikes'].values
+        iv = group['mark_iv'].values
+        vega = group['vega'].values if 'vega' in group.columns else np.ones_like(iv)
+        k = np.log(K / self.s)
+
+        # Filter out invalid data
+        w = (iv ** 2) * t
+        mask = ~np.isnan(w) & ~np.isnan(vega) & ~np.isnan(k) & (iv >= 0)
+        k, w, vega, iv, K = k[mask], w[mask], vega[mask], iv[mask], K[mask]
+
+        return maturity_name, t, k, w, vega, iv, K
+
+    def calculate_model_stats(self, params, t, k, iv):
+        """Calculate all model statistics from parameters"""
+        a, b, m, rho, sigma = params
+        a_scaled, b_scaled = a * t, b * t
+
+        # Jump-Wing parameters
+        jw_params = SVIModel.raw_to_jw_params(a_scaled, b_scaled, m, rho, sigma, t)
+
+        # Fit statistics
+        w_model = np.array([SVIModel.svi(x, a_scaled, b_scaled, m, rho, sigma) for x in k])
+        iv_model = np.sqrt(w_model / t)
+        rmse = np.sqrt(mean_squared_error(iv, iv_model))
+        mae = mean_absolute_error(iv, iv_model)
+        r2 = r2_score(iv, iv_model)
+        max_error = np.max(np.abs(iv - iv_model))
+
+        # Minimum strike
+        log_min_strike = SVIModel.svi_min_strike(sigma, rho, m)
+        usd_min_strike = np.exp(log_min_strike) * self.s
+
+        # Butterfly arbitrage check
+        k_range = np.linspace(min(k), max(k), self.num_points)
+        butterfly_arbitrage_free = SVIModel.check_butterfly_arbitrage(a_scaled, b_scaled, m, rho, sigma, k_range)
+
+        return {
+            'a': float(a_scaled),
+            'b': float(b_scaled),
+            'm': float(m),
+            'rho': float(rho),
+            'sigma': float(sigma),
+            'nu': float(jw_params[0]),
+            'psi': float(jw_params[1]),
+            'p': float(jw_params[2]),
+            'c': float(jw_params[3]),
+            'nu_tilde': float(jw_params[4]),
+            'log_min_strike': float(log_min_strike),
+            'usd_min_strike': float(usd_min_strike),
+            'butterfly_arbitrage_free': butterfly_arbitrage_free,
+            'rmse': float(rmse),
+            'mae': float(mae),
+            'r2': float(r2),
+            'max_error': float(max_error)
+        }
+
+    def process_maturity(self, maturity, group):
+        """Process single maturity for SVI calibration"""
+        # Clean and prepare market data
+        maturity_name, t, k, w, vega, iv, K = self.filter_market_data(group)
+
+        # Not enough data points for fitting
+        if len(k) <= 5:
+            result = self.failed_calibration(maturity, maturity_name, t, len(k))
+            logger.error(f'FAILED for {maturity} (insufficient data points)')
+            self.update_results(result)
+            return maturity
+
+        # Perform SVI fitting
+        params, loss = SVIModel.fit(tiv=w, vega=vega, k=k, tau=t)
+
+        # If fitting failed
+        if np.isnan(params[0]):
+            result = self.failed_calibration(maturity, maturity_name, t, len(k))
+            logger.error(f'FAILED for {maturity}')
+            self.update_results(result)
+            return maturity
+
+        # Successful fitting
+        self.params_dict[maturity] = (t, params)
+
+        # Calculate all model statistics
+        stats = self.calculate_model_stats(params, t, k, iv)
+
+        # Create result dictionary
+        result = {
+            's': float(self.s),
+            't': float(t),
+            'maturity_date': maturity,
+            'maturity_name': maturity_name,
+            'fit_success': True,
+            'calendar_arbitrage_free': True,  # Updated later
+            'loss': float(loss),
+            'n_points': int(len(k)),
+            **stats
+        }
+
+        logger.info(
+            f'SUCCESS for {maturity}: a={stats["a"]:.4f}, b={stats["b"]:.4f}, m={stats["m"]:.4f}, rho={stats["rho"]:.4f}, sigma={stats["sigma"]:.4f}')
+
+        self.update_results(result)
+        return maturity
+
+    def update_results(self, result_row):
+        """Update results data dictionary"""
+        for key, value in result_row.items():
+            if key in self.results_data:
+                self.results_data[key].append(value)
+
+    def fit_model(self):
+        """Execute full SVI calibration process"""
+        start_time = time.time()
+        logger.info(f"Processing {self.currency} option chain data...")
+
+        # Process all maturities in parallel
+        with ThreadPoolExecutor() as executor:
+            futures = [
+                executor.submit(self.process_maturity, maturity, group)
+                for maturity, group in self.groups
+            ]
+            for future in futures:
+                future.result()
+
+        # Create results DataFrame and mapping for updates
+        fit_results = pd.DataFrame(self.results_data, index=self.results_data['maturity_name'])
+        fit_results = fit_results.sort_values(by='t')
+        maturity_name_dict = {row['maturity_date']: idx for idx, row in fit_results.iterrows()}
+
+        # Check for calendar arbitrage
+        sorted_maturities = sorted(self.params_dict.keys(), key=lambda x: self.params_dict[x][0])
+        calendar_arbitrage_free = SVIModel.check_calendar_arbitrage(
+            sorted_maturities, self.params_dict, self.groups, self.s, self.num_points
+        )
+
+        # Update calendar arbitrage status
+        for mat in sorted_maturities:
+            mat_name = maturity_name_dict[mat]
+            fit_results.at[mat_name, 'calendar_arbitrage_free'] = calendar_arbitrage_free
+
+        # Correct calendar arbitrage violations
+        self.correct_calendar_arbitrage(sorted_maturities, fit_results, maturity_name_dict)
+
+        # Clean up results and report execution time
+        fit_results = fit_results.drop(columns='maturity_name')
+        end_time = time.time()
+        logger.info(f"Total model execution time: {end_time - start_time:.4f} seconds")
+
+        return fit_results
+
+    def correct_calendar_arbitrage(self, sorted_maturities, fit_results, maturity_name_dict):
+        """Handle calendar arbitrage corrections"""
+        for i in range(1, len(sorted_maturities)):
+            mat2 = sorted_maturities[i]
+            mat1 = sorted_maturities[i - 1]
+            t2, params2 = self.params_dict[mat2]
+            t1, params1 = self.params_dict[mat1]
+
+            if np.any(np.isnan(params2)) or np.any(np.isnan(params1)):
+                continue
+
+            # Get clean data for correction
+            _, _, k, w, vega, iv, _ = self.filter_market_data(self.groups.get_group(mat2))
+
+            # Apply correction
+            k_constraint = np.unique(np.concatenate([k, np.linspace(min(k), max(k), self.num_points)]))
+            new_params = SVIModel.correct_calendar_arbitrage(
+                params=params2, t=t2, tiv=w, vega=vega, k=k,
+                prev_params=params1, prev_t=t1, k_constraint=k_constraint
+            )
+
+            # Update params dictionary
+            self.params_dict[mat2] = (t2, new_params)
+
+            # Calculate new stats and update results
+            stats = self.calculate_model_stats(new_params, t2, k, iv)
+            mat2_name = maturity_name_dict[mat2]
+
+            # Update all stats at once
+            for key, value in stats.items():
+                fit_results.at[mat2_name, key] = value
+            fit_results.at[mat2_name, 'fit_success'] = True
+
+        # Final calendar arbitrage check
+        calendar_arbitrage_free = SVIModel.check_calendar_arbitrage(
+            sorted_maturities, self.params_dict, self.groups, self.s, self.num_points
+        )
+
+        # Update final status
+        for mat in sorted_maturities:
+            mat_name = maturity_name_dict[mat]
+            fit_results.at[mat_name, 'calendar_arbitrage_free'] = calendar_arbitrage_free
+
+
+@catch_exception
+def fit_model(option_chain: pd.DataFrame, num_points: int = 2000) -> pd.DataFrame:
+    """
+    Fit a volatility model to market data with parallel processing.
+
+    Parameters:
+    - option_chain: DataFrame with market data
+    - num_points: Number of points for k_grid and plotting
+
+    Returns:
+    - fit_results: DataFrame with all fit results and performance metrics as columns, maturity_names as index
+    """
+    currency = option_chain['currency'].iloc[0] if 'currency' in option_chain.columns else 'Unknown'
+
+    # Instantiate the calibrator and run the fitting
+    calibrator = SVICalibrator(option_chain, currency, num_points)
+    fit_results = calibrator.fit_model()
+
+    return fit_results
+
+
+@catch_exception
+def get_iv_surface(model_results: pd.DataFrame,
+                   domain_params: Tuple[float, float, int] = (-1.5, 1.5, 1000),
+                   return_domain: str = 'log_moneyness') -> Tuple[Dict[str, np.ndarray], Dict[str, np.ndarray]]:
+    """
+    Generate implied volatility surface using optimized SVI parameters.
+
+    Works with both regular fit_results and interpolated_results dataframes.
+
+    Parameters:
+    - model_results: DataFrame from fit_model() or interpolate_model(). Maturity names or DTM as Index
+    - domain_params: Tuple of (min, max, num_points) for the log-moneyness array
+    - return_domain: Domain for x-axis values ('log_moneyness', 'moneyness', 'returns', 'strikes', 'delta')
+
+    Returns:
+    - Tuple of (iv_surface, x_surface)
+      iv_surface: Dictionary mapping maturity to IV arrays
+      x_surface: Dictionary mapping maturity to requested x domain arrays
+    """
+    # Check if required columns are present
+    required_columns = ['a', 'b', 'm', 'rho', 'sigma', 't', 's']
+    missing_columns = [col for col in required_columns if col not in model_results.columns]
+    if missing_columns:
+        raise VolyError(f"Required columns missing in model_results: {missing_columns}")
+
+    # Generate implied volatility surface in log-moneyness domain
+    LM = np.linspace(domain_params[0], domain_params[1], domain_params[2])
+
+    iv_surface = {}
+    x_surface = {}
+
+    # Process each maturity/dtm
+    for i in model_results.index:
+        # Calculate SVI total implied variance and convert to IV
+        params = [
+            model_results.loc[i, 'a'],
+            model_results.loc[i, 'b'],
+            model_results.loc[i, 'm'],
+            model_results.loc[i, 'rho'],
+            model_results.loc[i, 'sigma']
+        ]
+        s = model_results.loc[i, 's']
+        t = model_results.loc[i, 't']
+        r = model_results.loc[i, 'r'] if 'r' in model_results.columns else 0
+
+        # Calculate implied volatility
+        w = np.array([SVIModel.svi(x, *params) for x in LM])
+        o = np.sqrt(w / t)
+        iv_surface[i] = o
+
+        # Calculate x domain for this maturity/dtm
+        x = get_domain(domain_params, s, r, o, t, return_domain)
+        x_surface[i] = x
+
+    return iv_surface, x_surface

{voly-0.0.203 → voly-0.0.205}/src/voly/models.py

@@ -40,18 +40,28 @@ class SVIModel:
         return a + b * (rho * (k - m) + np.sqrt((k - m) ** 2 + sigma ** 2))
 
     @staticmethod
-    def svi_min_strike(sigma: float, rho: float, m: float) -> float:
+    def svi_d(k, b, m, rho, sigma):
+        """Compute the derivative of SVI over K"""
+        return b * (rho + (k - m) / np.sqrt((k - m) ** 2 + sigma ** 2))
+
+    @staticmethod
+    def svi_dd(k, b, m, sigma):
+        """Compute the second derivative of SVI over K"""
+        return b * sigma ** 2 / ((k - m) ** 2 + sigma ** 2) ** (3 / 2)
+
+    @staticmethod
+    def svi_min_strike(sigma, rho, m):
         """Calculate the minimum valid log-strike for this SVI parameterization."""
         return m - ((sigma * rho) / np.sqrt(1 - rho ** 2))
 
     @staticmethod
-    def raw_to_jw_params(a: float, b: float, m: float, rho: float, sigma: float, t: float) -> Tuple[
-        float, float, float, float, float]:
+    def raw_to_jw_params(a, b, m, rho, sigma, t):
         """Convert raw SVI to Jump-Wing parameters."""
         nu = (a + b * ((-rho) * m + np.sqrt(m ** 2 + sigma ** 2))) / t
-        psi = (1 / np.sqrt(nu * t)) * (b / 2) * (rho - (m / np.sqrt(m ** 2 + sigma ** 2)))
-        p = (1 / np.sqrt(nu * t)) * b * (1 - rho)
-        c = (1 / np.sqrt(nu * t)) * b * (1 + rho)
+        sqrt_nu_t = np.sqrt(nu * t)
+        psi = (1 / sqrt_nu_t) * (b / 2) * (rho - (m / np.sqrt(m ** 2 + sigma ** 2)))
+        p = (1 / sqrt_nu_t) * b * (1 - rho)
+        c = (1 / sqrt_nu_t) * b * (1 + rho)
         nu_tilde = (1 / t) * (a + b * sigma * np.sqrt(1 - rho ** 2))
         return nu, psi, p, c, nu_tilde
 
@@ -67,6 +77,8 @@ class SVIModel:
         sigma = max(sigma, 0.001)
         vega = vega / vega.max() if vega.max() > 0 else np.ones_like(vega)
         y = (k - m) / sigma
+
+        # Calculate means for matrix construction
         w = vega.mean()
         y1 = (vega * y).mean()
         y2 = (vega * y * y).mean()
@@ -77,38 +89,40 @@ class SVIModel:
         vy = (vega * tiv * y).mean()
         v = (vega * tiv).mean()
 
-        matrix = [[y5, y4, y3], [y4, y2, y1], [y3, y1, w]]
-        vector = [vy2, vy, v]
-        c, d, a = solve(np.array(matrix), np.array(vector))
+        # Solve the linear system
+        matrix = np.array([[y5, y4, y3], [y4, y2, y1], [y3, y1, w]])
+        vector = np.array([vy2, vy, v])
+        c, d, a = solve(matrix, vector)
 
+        # Clip parameters to ensure validity
         c = np.clip(c, 0, 4 * sigma)
         a = max(a, 1e-6)
         d = np.clip(d, -min(c, 4 * sigma - c), min(c, 4 * sigma - c))
 
-        loss = cls.loss(tiv, vega, y, c, d, a)
-        return c, d, a, loss
+        return c, d, a, cls.loss(tiv, vega, y, c, d, a)
 
     @classmethod
     def fit(cls, tiv, vega, k, tau=1.0):
         """Fit SVI model."""
         if len(k) <= 5:
             return [np.nan] * 5, np.inf
+
         vega = vega / vega.max() if vega.max() > 0 else np.ones_like(vega)
         m_init = np.mean(k)
         sigma_init = max(0.1, np.std(k) * 0.1)
 
-        def score(params):
-            sigma, m = params
-            c, d, a_calib, loss = cls.calibration(tiv, vega, k, m, sigma)
-            return loss
-
-        result = minimize(score, [sigma_init, m_init], bounds=[(0.001, None), (None, None)],
-                          tol=1e-16, method="SLSQP", options={'maxfun': 5000})
+        result = minimize(
+            lambda params: cls.calibration(tiv, vega, k, params[1], params[0])[3],
+            [sigma_init, m_init],
+            bounds=[(0.001, None), (None, None)],
+            tol=1e-16, method="SLSQP", options={'maxfun': 5000}
+        )
 
         sigma, m = result.x
         c, d, a_calib, loss = cls.calibration(tiv, vega, k, m, sigma)
         a_calib = max(a_calib, 1e-6)
 
+        # Convert to SVI parameters
         if c != 0:
             a_svi = a_calib / tau
             rho_svi = d / c
@@ -120,13 +134,13 @@ class SVIModel:
         return [a_svi, b_svi, m, rho_svi, sigma], loss
 
     @classmethod
-    def correct_calendar_arbitrage(cls, params, t, tiv, vega, k, prev_params, prev_t, k_grid):
+    def correct_calendar_arbitrage(cls, params, t, tiv, vega, k, prev_params, prev_t, k_constraint):
+        """Correct calendar arbitrage with relaxed bounds."""
         if np.any(np.isnan(params)) or np.any(np.isnan(prev_params)):
             return params
 
         a_init, b_init, m_init, rho_init, sigma_init = params
         a_prev, b_prev, m_prev, rho_prev, sigma_prev = prev_params
-        k_constraint = np.unique(np.concatenate([k, np.linspace(min(k), max(k), len(k_grid))]))
 
         def objective(x):
             a, b, m, rho, sigma = x
@@ -136,12 +150,6 @@ class SVIModel:
                                   for i, x_init in enumerate([a_init, b_init, m_init, rho_init, sigma_init]))
             return fit_loss + 0.01 * param_deviation
 
-        def calendar_constraint(x):
-            a, b, m, rho, sigma = x
-            w_current = cls.svi(k_constraint, a * t, b * t, m, rho, sigma)
-            w_prev = cls.svi(k_constraint, a_prev * prev_t, b_prev * prev_t, m_prev, rho_prev, sigma_prev)
-            return w_current - w_prev
-
         bounds = [
             (max(a_init * 0.8, 1e-6), a_init * 1.2),
             (max(b_init * 0.8, 0), b_init * 1.2),
@@ -151,7 +159,9 @@ class SVIModel:
         ]
 
         constraints = [
-            {'type': 'ineq', 'fun': calendar_constraint},
+            {'type': 'ineq', 'fun': lambda x: cls.svi(k_constraint, x[0] * t, x[1] * t, x[2], x[3], x[4]) -
+                                              cls.svi(k_constraint, a_prev * prev_t, b_prev * prev_t, m_prev, rho_prev,
+                                                      sigma_prev)},
             {'type': 'ineq', 'fun': lambda x: x[0] + x[1] * x[4] * np.sqrt(1 - x[3] ** 2)}
         ]
 
@@ -166,13 +176,56 @@ class SVIModel:
             w_current = cls.svi(k_constraint, new_params[0] * t, new_params[1] * t, *new_params[2:])
             w_prev = cls.svi(k_constraint, a_prev * prev_t, b_prev * prev_t, m_prev, rho_prev, sigma_prev)
             violation = np.min(w_current - w_prev)
-            logger.info(
-                f"Calendar arbitrage correction {'successful' if violation >= -1e-6 else 'failed'} for t={t:.4f}, "
-                f"min margin={violation:.6f}")
+            print(f"Calendar arbitrage correction {'successful' if violation >= -1e-6 else 'failed'} for t={t:.4f}, "
+                  f"min margin={violation:.6f}")
             return new_params
-        logger.warning(f"Calendar arbitrage correction failed for t={t:.4f}")
+
+        print(f"Calendar arbitrage correction failed for t={t:.4f}")
         return params
 
+    @classmethod
+    def check_butterfly_arbitrage(cls, a, b, m, rho, sigma, k_range):
+        """Check for butterfly arbitrage violations."""
+        for k_val in k_range:
+            w_k = cls.svi(k_val, a, b, m, rho, sigma)
+            w_d_k = cls.svi_d(k_val, b, m, rho, sigma)
+            w_dd_k = cls.svi_dd(k_val, b, m, sigma)
+            g = (1 - (k_val * w_d_k) / (2 * w_k)) ** 2 - (w_d_k ** 2) / 4 * (1 / w_k + 1 / 4) + w_dd_k / 2
+            if g < 0:
+                return False
+        return True
+
+    @classmethod
+    def check_calendar_arbitrage(cls, sorted_maturities, params_dict, groups, s, num_points):
+        """Check for calendar arbitrage violations."""
+        for i in range(len(sorted_maturities) - 1):
+            mat1, mat2 = sorted_maturities[i], sorted_maturities[i + 1]
+            t1, params1 = params_dict[mat1]
+            t2, params2 = params_dict[mat2]
+            a1, b1, m1, rho1, sigma1 = params1
+            a2, b2, m2, rho2, sigma2 = params2
+
+            if np.isnan(a1) or np.isnan(a2):
+                continue
+
+            # Get strike range for checking
+            group = groups.get_group(mat2)
+            K = group['strikes'].values
+            k_market = np.log(K / s)
+            mask = ~np.isnan(k_market)
+            k_check = np.unique(
+                np.concatenate([k_market[mask], np.linspace(min(k_market[mask]), max(k_market[mask]), num_points)]))
+
+            # Check for violations
+            for k_val in k_check:
+                w1 = cls.svi(k_val, a1 * t1, b1 * t1, m1, rho1, sigma1)
+                w2 = cls.svi(k_val, a2 * t2, b2 * t2, m2, rho2, sigma2)
+                if w2 < w1 - 1e-6:
+                    print(
+                        f"Calendar arbitrage violation at t1={t1:.4f}, t2={t2:.4f}, k={k_val:.4f}: w1={w1:.6f}, w2={w2:.6f}")
+                    return False
+        return True
+
 
 # Models dictionary for easy access
 MODELS = {

{voly-0.0.203 → voly-0.0.205/src/voly.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: voly
-Version: 0.0.203
+Version: 0.0.205
 Summary: Options & volatility research package
 Author-email: Manu de Cara <manu.de.cara@gmail.com>
 License: MIT

voly-0.0.203/src/voly/core/fit.py

@@ -1,410 +0,0 @@
-"""
-Model fitting and calibration module for the Voly package.
-
-This module handles fitting volatility models to market data, calculating fitting statistics,
-and generating visualizations.
-"""
-
-import numpy as np
-import pandas as pd
-from typing import List, Tuple, Dict, Optional, Union, Any
-from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
-from voly.utils.logger import logger, catch_exception
-from voly.formulas import get_domain
-from voly.exceptions import VolyError
-from voly.models import SVIModel
-from concurrent.futures import ThreadPoolExecutor
-import warnings
-import time
-import plotly.graph_objects as go
-from plotly.subplots import make_subplots
-
-warnings.filterwarnings("ignore")
-
-
-@catch_exception
-def fit_model(option_chain: pd.DataFrame, num_points: int = 2000) -> Tuple[pd.DataFrame, Dict]:
-    """
-    Fit a volatility model to market data with parallel processing and generate visualizations.
-
-    Parameters:
-    - option_chain: DataFrame with market data
-    - num_points: Number of points for k_grid and plotting
-
-    Returns:
-    - results_df: DataFrame with all fit results and performance metrics as columns, maturity_names as index
-    """
-    # Start overall timer
-    start_total = time.time()
-
-    # Define column names and their data types
-    column_dtypes = {
-        's': float,
-        't': float,
-        'maturity_date': 'datetime64[ns]',
-        'a': float,
-        'b': float,
-        'm': float,
-        'rho': float,
-        'sigma': float,
-        'nu': float,
-        'psi': float,
-        'p': float,
-        'c': float,
-        'nu_tilde': float,
-        'log_min_strike': float,
-        'usd_min_strike': float,
-        'fit_success': bool,
-        'butterfly_arbitrage_free': bool,
-        'calendar_arbitrage_free': bool,
-        'rmse': float,
-        'mae': float,
-        'r2': float,
-        'max_error': float,
-        'loss': float,
-        'n_points': int
-    }
-
-    s = option_chain['index_price'].iloc[0]
-    maturity_data_groups = option_chain.groupby('maturity_date')
-    params_dict = {}
-    results_data = {col: [] for col in column_dtypes.keys()}
-    results_data['maturity_name'] = []
-
-    def process_maturity(maturity, maturity_data):
-        """Process single maturity for SVI calibration."""
-        maturity_data = maturity_data[maturity_data['option_type'] == 'C']
-        duplicated_iv = maturity_data[maturity_data.duplicated('mark_iv', keep=False)]
-
-        # For each duplicated IV, keep the row closest to log_moneyness=0
-        def keep_closest_to_zero(subgroup):
-            idx = (subgroup['log_moneyness'].abs()).idxmin()
-            return subgroup.loc[[idx]]
-
-        # Apply the function to each duplicated mark_iv group
-        cleaned_duplicated_iv = (
-            duplicated_iv.groupby('mark_iv', group_keys=False)
-            .apply(keep_closest_to_zero)
-        )
-
-        # Get rows with unique mark_iv (no duplicates)
-        unique_iv = maturity_data.drop_duplicates('mark_iv', keep=False)
-
-        # Combine cleaned duplicates and unique rows
-        maturity_data = pd.concat([unique_iv, cleaned_duplicated_iv])
-        maturity_date = maturity_data['maturity_date'].iloc[0]
-        maturity_name = maturity_data['maturity_name'].iloc[0]
-
-        t = maturity_data['t'].iloc[0]
-        K = maturity_data['strikes'].values
-        iv = maturity_data['mark_iv'].values
-        vega = maturity_data['vega'].values if 'vega' in maturity_data.columns else np.ones_like(iv)
-        k = np.log(K / s)
-        w = (iv ** 2) * t
-        mask = ~np.isnan(w) & ~np.isnan(vega) & ~np.isnan(k) & (iv >= 0)
-        k, w, vega, iv = k[mask], w[mask], vega[mask], iv[mask]
-
-        params = [np.nan] * 5
-        loss = np.inf
-        nu = psi = p = c = nu_tilde = np.nan
-        rmse = mae = r2 = max_error = np.nan
-        butterfly_arbitrage_free = True
-        log_min_strike = usd_min_strike = np.nan
-
-        if len(k) > 5:
-            params, loss = SVIModel.fit(tiv=w, vega=vega, k=k, tau=t)
-            if not np.isnan(params[0]):
-                params_dict[maturity_date] = (t, params)
-                a, b, m, rho, sigma = params
-                a_scaled, b_scaled = a * t, b * t
-                nu, psi, p, c, nu_tilde = SVIModel.raw_to_jw_params(a_scaled, b_scaled, m, rho, sigma, t)
-
-                # Compute fit statistics
-                w_model = np.array([SVIModel.svi(x, a_scaled, b_scaled, m, rho, sigma) for x in k])
-                iv_model = np.sqrt(w_model / t)
-                iv_market = iv
-                rmse = np.sqrt(mean_squared_error(iv_market, iv_model))
-                mae = mean_absolute_error(iv_market, iv_model)
-                r2 = r2_score(iv_market, iv_model)
-                max_error = np.max(np.abs(iv_market - iv_model))
-
-                # Compute min strike
-                log_min_strike = SVIModel.svi_min_strike(sigma, rho, m)
-                usd_min_strike = np.exp(log_min_strike) * s
-
-                # Butterfly arbitrage check
-                k_range = np.linspace(min(k), max(k), num_points)
-                w_k = lambda k: SVIModel.svi(k, a_scaled, b_scaled, m, rho, sigma)
-                w_prime = lambda k: b_scaled * (rho + (k - m) / np.sqrt((k - m)**2 + sigma**2))
-                w_double_prime = lambda k: b_scaled * sigma**2 / ((k - m)**2 + sigma**2)**(3/2)
-                for k_val in k_range:
-                    wk = w_k(k_val)
-                    wp = w_prime(k_val)
-                    wpp = w_double_prime(k_val)
-                    g = (1 - (k_val * wp) / (2 * wk))**2 - (wp**2) / 4 * (1 / wk + 1/4) + wpp / 2
-                    if g < 0:
-                        butterfly_arbitrage_free = False
-                        break
-
-        # Log result
-        GREEN, RED, RESET = '\033[32m', '\033[31m', '\033[0m'
-        status = f'{GREEN}SUCCESS{RESET}' if not np.isnan(params[0]) else f'{RED}FAILED{RESET}'
-        logger.info(f'Optimization for {maturity_date}: {status}')
-
-        # Store results
-        results_data['s'].append(float(s))
-        results_data['t'].append(float(t))
-        results_data['maturity_date'].append(maturity_date)
-        results_data['maturity_name'].append(maturity_name)
-        results_data['a'].append(float(a_scaled) if not np.isnan(params[0]) else np.nan)
-        results_data['b'].append(float(b_scaled) if not np.isnan(params[0]) else np.nan)
-        results_data['m'].append(float(m))
-        results_data['rho'].append(float(rho))
-        results_data['sigma'].append(float(sigma))
-        results_data['nu'].append(float(nu))
-        results_data['psi'].append(float(psi))
-        results_data['p'].append(float(p))
-        results_data['c'].append(float(c))
-        results_data['nu_tilde'].append(float(nu_tilde))
-        results_data['log_min_strike'].append(float(log_min_strike))
-        results_data['usd_min_strike'].append(float(usd_min_strike))
-        results_data['fit_success'].append(bool(not np.isnan(params[0])))
-        results_data['butterfly_arbitrage_free'].append(butterfly_arbitrage_free)
-        results_data['calendar_arbitrage_free'].append(True)  # Updated after check
-        results_data['rmse'].append(float(rmse))
-        results_data['mae'].append(float(mae))
-        results_data['r2'].append(float(r2))
-        results_data['max_error'].append(float(max_error))
-        results_data['loss'].append(float(loss))
-        results_data['n_points'].append(int(len(k)))
-
-        return maturity_name
-
-    # Parallel processing of maturities
-    with ThreadPoolExecutor() as executor:
-        futures = [executor.submit(process_maturity, maturity, maturity_data)
-                   for maturity, maturity_data in maturity_data_groups]
-        for future in futures:
-            future.result()
-
-    # Create results DataFrame
-    results_df = pd.DataFrame(results_data, index=results_data['maturity_name'])
-
-    # Map maturity_date to maturity_name for indexing
-    date_to_name = dict(zip(results_data['maturity_date'], results_data['maturity_name']))
-
-    # Convert columns to appropriate types
-    for col, dtype in column_dtypes.items():
-        if col in results_df.columns:
-            try:
-                results_df[col] = results_df[col].astype(dtype)
-            except (ValueError, TypeError) as e:
-                logger.warning(f"Could not convert column {col} to {dtype}: {e}")
-
-    # Sort by time to maturity
-    results_df = results_df.sort_values(by='t')
-
-    # Calendar arbitrage check (pre-correction)
-    k_grid = np.linspace(-2, 2, num_points)
-    sorted_maturities = sorted(params_dict.keys(), key=lambda x: params_dict[x][0])
-    calendar_arbitrage_free = True
-    for i in range(len(sorted_maturities) - 1):
-        mat1, mat2 = sorted_maturities[i], sorted_maturities[i + 1]
-        t1, params1 = params_dict[mat1]
-        t2, params2 = params_dict[mat2]
-        a1, b1, m1, rho1, sigma1 = params1
-        a2, b2, m2, rho2, sigma2 = params2
-
-        if np.isnan(a1) or np.isnan(a2):
-            continue
-
-        maturity_data = maturity_data_groups.get_group(mat2)
-        K = maturity_data['strikes'].values
-        k_market = np.log(K / s)
-        mask = ~np.isnan(k_market)
-        k_check = np.unique(np.concatenate([k_market[mask], np.linspace(min(k_market[mask]), max(k_market[mask]), num_points)]))
-
-        for k_val in k_check:
-            w1 = SVIModel.svi(k_val, a1 * t1, b1 * t1, m1, rho1, sigma1)
-            w2 = SVIModel.svi(k_val, a2 * t2, b2 * t2, m2, rho2, sigma2)
-            if w2 < w1 - 1e-6:
-                logger.warning(f"Calendar arbitrage violation at t1={t1:.4f}, t2={t2:.4f}, k={k_val:.4f}: w1={w1:.6f}, w2={w2:.6f}")
-                calendar_arbitrage_free = False
-                break
-        if not calendar_arbitrage_free:
-            break
-
-    for mat in sorted_maturities:
-        results_df.at[date_to_name[mat], 'calendar_arbitrage_free'] = calendar_arbitrage_free
-
-    # Calendar arbitrage correction
-    for i in range(1, len(sorted_maturities)):
-        mat2 = sorted_maturities[i]
-        mat1 = sorted_maturities[i - 1]
-        t2, params2 = params_dict[mat2]
-        t1, params1 = params_dict[mat1]
-
-        if np.any(np.isnan(params2)) or np.any(np.isnan(params1)):
-            continue
-
-        maturity_data = maturity_data_groups.get_group(mat2)
-        K = maturity_data['strikes'].values
-        iv = maturity_data['mark_iv'].values
-        vega = maturity_data['vega'].values if 'vega' in maturity_data.columns else np.ones_like(iv)
-        k = np.log(K / s)
-        w = (iv ** 2) * t2
-        mask = ~np.isnan(w) & ~np.isnan(vega) & ~np.isnan(k) & (iv >= 0)
-        k, w, vega, iv = k[mask], w[mask], vega[mask], iv[mask]
-
-        new_params = SVIModel.correct_calendar_arbitrage(
-            params=params2, t=t2, tiv=w, vega=vega, k=k,
-            prev_params=params1, prev_t=t1, k_grid=k_grid
-        )
-
-        params_dict[mat2] = (t2, new_params)
-        a, b, m, rho, sigma = new_params
-        a_scaled, b_scaled = a * t2, b * t2
-        nu, psi, p, c, nu_tilde = SVIModel.raw_to_jw_params(a_scaled, b_scaled, sigma, rho, m, t2)
-
-        # Recompute fit statistics
-        w_model = np.array([SVIModel.svi(x, a_scaled, b_scaled, m, rho, sigma) for x in k])
-        iv_model = np.sqrt(w_model / t2)
-        iv_market = iv
-        rmse = np.sqrt(mean_squared_error(iv_market, iv_model))
-        mae = mean_absolute_error(iv_market, iv_model)
-        r2 = r2_score(iv_market, iv_model)
-        max_error = np.max(np.abs(iv_market - iv_model))
-
-        # Recompute min strike
-        log_min_strike = SVIModel.svi_min_strike(sigma, rho, m)
-        usd_min_strike = np.exp(log_min_strike) * s
-
-        # Update butterfly arbitrage check
-        butterfly_arbitrage_free = True
-        k_range = np.linspace(min(k), max(k), num_points)
-        w_k = lambda k: SVIModel.svi(k, a_scaled, b_scaled, m, rho, sigma)
-        w_prime = lambda k: b_scaled * (rho + (k - m) / np.sqrt((k - m)**2 + sigma**2))
-        w_double_prime = lambda k: b_scaled * sigma**2 / ((k - m)**2 + sigma**2)**(3/2)
-        for k_val in k_range:
-            wk = w_k(k_val)
-            wp = w_prime(k_val)
-            wpp = w_double_prime(k_val)
-            g = (1 - (k_val * wp) / (2 * wk))**2 - (wp**2) / 4 * (1 / wk + 1/4) + wpp / 2
-            if g < 0:
-                butterfly_arbitrage_free = False
-                break
-
-        results_df.at[date_to_name[mat2], 'a'] = float(a_scaled)
-        results_df.at[date_to_name[mat2], 'b'] = float(b_scaled)
-        results_df.at[date_to_name[mat2], 'm'] = float(m)
-        results_df.at[date_to_name[mat2], 'rho'] = float(rho)
-        results_df.at[date_to_name[mat2], 'sigma'] = float(sigma)
-        results_df.at[date_to_name[mat2], 'nu'] = float(nu)
-        results_df.at[date_to_name[mat2], 'psi'] = float(psi)
-        results_df.at[date_to_name[mat2], 'p'] = float(p)
-        results_df.at[date_to_name[mat2], 'c'] = float(c)
-        results_df.at[date_to_name[mat2], 'nu_tilde'] = float(nu_tilde)
-        results_df.at[date_to_name[mat2], 'rmse'] = float(rmse)
-        results_df.at[date_to_name[mat2], 'mae'] = float(mae)
-        results_df.at[date_to_name[mat2], 'r2'] = float(r2)
-        results_df.at[date_to_name[mat2], 'max_error'] = float(max_error)
-        results_df.at[date_to_name[mat2], 'log_min_strike'] = float(log_min_strike)
-        results_df.at[date_to_name[mat2], 'usd_min_strike'] = float(usd_min_strike)
-        results_df.at[date_to_name[mat2], 'butterfly_arbitrage_free'] = butterfly_arbitrage_free
-        results_df.at[date_to_name[mat2], 'fit_success'] = bool(not np.isnan(a))
-
-    # Calendar arbitrage check (post-correction)
-    calendar_arbitrage_free = True
-    for i in range(len(sorted_maturities) - 1):
-        mat1, mat2 = sorted_maturities[i], sorted_maturities[i + 1]
-        t1, params1 = params_dict[mat1]
-        t2, params2 = params_dict[mat2]
-        a1, b1, m1, rho1, sigma1 = params1
-        a2, b2, m2, rho2, sigma2 = params2
-
-        if np.isnan(a1) or np.isnan(a2):
-            continue
-
-        maturity_data = maturity_data_groups.get_group(mat2)
-        K = maturity_data['strikes'].values
-        k_market = np.log(K / s)
-        mask = ~np.isnan(k_market)
-        k_check = np.unique(np.concatenate([k_market[mask], np.linspace(min(k_market[mask]), max(k_market[mask]), num_points)]))
-
-        for k_val in k_check:
-            w1 = SVIModel.svi(k_val, a1 * t1, b1 * t1, m1, rho1, sigma1)
-            w2 = SVIModel.svi(k_val, a2 * t2, b2 * t2, m2, rho2, sigma2)
-            if w2 < w1 - 1e-6:
-                logger.warning(f"Calendar arbitrage violation at t1={t1:.4f}, t2={t2:.4f}, k={k_val:.4f}: w1={w1:.6f}, w2={w2:.6f}")
-                calendar_arbitrage_free = False
-                break
-        if not calendar_arbitrage_free:
-            break
-
-    for mat in sorted_maturities:
-        results_df.at[date_to_name[mat], 'calendar_arbitrage_free'] = calendar_arbitrage_free
-
-    # End overall timer and print total time
-    end_total = time.time()
-    logger.info(f"Total execution time for the model: {end_total - start_total:.4f} seconds")
-
-    logger.info("Model fitting complete.")
-    results_df = results_df.drop(columns='maturity_name')
-    return results_df
-
-
-@catch_exception
-def get_iv_surface(model_results: pd.DataFrame,
-                   domain_params: Tuple[float, float, int] = (-1.5, 1.5, 1000),
-                   return_domain: str = 'log_moneyness') -> Tuple[Dict[str, np.ndarray], Dict[str, np.ndarray]]:
-    """
-    Generate implied volatility surface using optimized SVI parameters.
-
-    Works with both regular fit_results and interpolated_results dataframes.
-
-    Parameters:
-    - model_results: DataFrame from fit_model() or interpolate_model(). Maturity names or DTM as Index
-    - domain_params: Tuple of (min, max, num_points) for the log-moneyness array
-    - return_domain: Domain for x-axis values ('log_moneyness', 'moneyness', 'returns', 'strikes', 'delta')
-
-    Returns:
-    - Tuple of (iv_surface, x_surface)
-      iv_surface: Dictionary mapping maturity to IV arrays
-      x_surface: Dictionary mapping maturity to requested x domain arrays
-    """
-    # Check if required columns are present
-    required_columns = ['a', 'b', 'm', 'rho', 'sigma', 't', 's']
-    missing_columns = [col for col in required_columns if col not in model_results.columns]
-    if missing_columns:
-        raise VolyError(f"Required columns missing in model_results: {missing_columns}")
-
-    # Generate implied volatility surface in log-moneyness domain
-    LM = np.linspace(domain_params[0], domain_params[1], domain_params[2])
-
-    iv_surface = {}
-    x_surface = {}
-
-    # Process each maturity/dtm
-    for i in model_results.index:
-        # Calculate SVI total implied variance and convert to IV
-        params = [
-            model_results.loc[i, 'a'],
-            model_results.loc[i, 'b'],
-            model_results.loc[i, 'm'],
-            model_results.loc[i, 'rho'],
-            model_results.loc[i, 'sigma']
-        ]
-        s = model_results.loc[i, 's']
-        t = model_results.loc[i, 't']
-        r = model_results.loc[i, 'r'] if 'r' in model_results.columns else 0
-
-        # Calculate implied volatility
-        w = np.array([SVIModel.svi(x, *params) for x in LM])
-        o = np.sqrt(w / t)
-        iv_surface[i] = o
-
-        # Calculate x domain for this maturity/dtm
-        x = get_domain(domain_params, s, r, o, t, return_domain)
-        x_surface[i] = x
-
-    return iv_surface, x_surface