voly 0.0.195__tar.gz → 0.0.196__tar.gz

{voly-0.0.195/src/voly.egg-info → voly-0.0.196}/PKG-INFO

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

{voly-0.0.195 → voly-0.0.196}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "voly"
-version = "0.0.195"
+version = "0.0.196"
 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.195"
+python_version = "0.0.196"
 warn_return_any = true
 warn_unused_configs = true
 disallow_untyped_defs = true

{voly-0.0.195 → voly-0.0.196}/src/voly/core/fit.py

@@ -1,8 +1,8 @@
 """
 Model fitting and calibration module for the Voly package.
 
-This module handles fitting volatility models to market data and
-calculating fitting statistics.
+This module handles fitting volatility models to market data, calculating fitting statistics,
+and generating visualizations.
 """
 
 import numpy as np
@@ -16,20 +16,25 @@ 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) -> pd.DataFrame:
+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.
+    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:
-    - DataFrame with all fit results and performance metrics as columns, maturity_names as index
+    - Tuple of (results_df, params_dict)
+      results_df: DataFrame with all fit results and performance metrics as columns, maturity_dates as index
+      params_dict: Dictionary mapping maturity_dates to (t, params)
     """
     # Start overall timer
     start_total = time.time()
@@ -38,7 +43,6 @@ def fit_model(option_chain: pd.DataFrame) -> pd.DataFrame:
     column_dtypes = {
         's': float,
         't': float,
-        'r': float,
         'maturity_date': 'datetime64[ns]',
         'a': float,
         'b': float,
@@ -55,22 +59,18 @@ def fit_model(option_chain: pd.DataFrame) -> pd.DataFrame:
         'fit_success': bool,
         'butterfly_arbitrage_free': bool,
         'calendar_arbitrage_free': bool,
-        'loss': float,
         'rmse': float,
         'mae': float,
         'r2': float,
         'max_error': float,
+        'loss': float,
         'n_points': int
     }
 
     s = option_chain['index_price'].iloc[0]
-    unique_ts = sorted(option_chain['t'].unique())
-    maturity_names = [option_chain[option_chain['t'] == t]['maturity_name'].iloc[0] for t in unique_ts]
-    maturity_dates = [option_chain[option_chain['t'] == t]['maturity_date'].iloc[0] for t in unique_ts]
     maturity_data_groups = option_chain.groupby('maturity_date')
     params_dict = {}
     results_data = {col: [] for col in column_dtypes.keys()}
-    num_points = 2000  # Number of points for k_grid
 
     def process_maturity(maturity, maturity_data):
         """Process single maturity for SVI calibration."""
@@ -94,7 +94,6 @@ def fit_model(option_chain: pd.DataFrame) -> pd.DataFrame:
         # 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
@@ -108,45 +107,53 @@ def fit_model(option_chain: pd.DataFrame) -> pd.DataFrame:
         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
-        r = maturity_data['interest_rate'].iloc[0] if 'interest_rate' in maturity_data.columns else 0
         log_min_strike = usd_min_strike = np.nan
 
         if len(k) > 5:
             params, loss = SVIModel.fit(tiv=w, vega=vega, k=k, tau=t)
-            a, b, m, rho, sigma = params
-            a_scaled, b_scaled = a * t, b * t
-            params_dict[maturity_date] = (t, params)
-            nu, psi, p, c, nu_tilde = SVIModel.raw_to_jw_params(a_scaled, b_scaled, m, rho, sigma, t)
-            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
-        else:
-            params = [np.nan] * 5
-            loss = np.inf
+            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_raw(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_raw(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}: {status}')
+        logger.info(f'Optimization for {maturity_date}: {status}')
 
         # Store results
         results_data['s'].append(float(s))
         results_data['t'].append(float(t))
-        results_data['r'].append(float(r))
         results_data['maturity_date'].append(maturity_date)
         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)
@@ -163,24 +170,24 @@ def fit_model(option_chain: pd.DataFrame) -> pd.DataFrame:
         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(np.nan)
-        results_data['mae'].append(np.nan)
-        results_data['r2'].append(np.nan)
-        results_data['max_error'].append(np.nan)
+        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
+        return maturity_date
 
     # Parallel processing of maturities
-    logger.info("\nStarting parallel processing of maturities...")
     with ThreadPoolExecutor() as executor:
         futures = [executor.submit(process_maturity, maturity, maturity_data)
                    for maturity, maturity_data in maturity_data_groups]
-        maturity_names = [future.result() for future in futures]
+        for future in futures:
+            future.result()
 
     # Create results DataFrame
-    results_df = pd.DataFrame(results_data, index=maturity_names)
+    results_df = pd.DataFrame(results_data, index=results_data['maturity_date'])
 
     # Convert columns to appropriate types
     for col, dtype in column_dtypes.items():
@@ -194,7 +201,6 @@ def fit_model(option_chain: pd.DataFrame) -> pd.DataFrame:
     results_df = results_df.sort_values(by='t')
 
     # Calendar arbitrage check (pre-correction)
-    logger.info("\nChecking calendar arbitrage (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
@@ -215,8 +221,8 @@ def fit_model(option_chain: pd.DataFrame) -> pd.DataFrame:
         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)
+            w1 = SVIModel.svi_raw(k_val, a1 * t1, b1 * t1, m1, rho1, sigma1)
+            w2 = SVIModel.svi_raw(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
@@ -224,11 +230,11 @@ def fit_model(option_chain: pd.DataFrame) -> pd.DataFrame:
         if not calendar_arbitrage_free:
             break
 
-    for mat in results_df['maturity_date']:
-        results_df.loc[results_df['maturity_date'] == mat, 'calendar_arbitrage_free'] = calendar_arbitrage_free
+    for mat in sorted_maturities:
+        results_df.at[mat, 'calendar_arbitrage_free'] = calendar_arbitrage_free
 
     # Calendar arbitrage correction
-    logger.info("Performing calendar arbitrage correction...")
+    start_correction = time.time()
     for i in range(1, len(sorted_maturities)):
         mat2 = sorted_maturities[i]
         mat1 = sorted_maturities[i - 1]
@@ -252,15 +258,13 @@ def fit_model(option_chain: pd.DataFrame) -> pd.DataFrame:
             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
-        params_dict[mat2] = (t2, new_params)
-        nu, psi, p, c, nu_tilde = SVIModel.raw_to_jw_params(a_scaled, b_scaled, m, rho, sigma, t2)
-        log_min_strike = SVIModel.svi_min_strike(sigma, rho, m)
-        usd_min_strike = np.exp(log_min_strike) * s
+        nu, psi, p, c, nu_tilde = SVIModel.raw_to_jw_params(a_scaled, b_scaled, sigma, rho, m, t2)
 
-        # Compute fit statistics
-        w_model = np.array([SVIModel.svi(x, a_scaled, b_scaled, m, rho, sigma) for x in k])
+        # Recompute fit statistics
+        w_model = np.array([SVIModel.svi_raw(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))
@@ -268,47 +272,49 @@ def fit_model(option_chain: pd.DataFrame) -> pd.DataFrame:
         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)
+        w_k = lambda k: SVIModel.svi_raw(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
+            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
 
-        # Update results_df using maturity_name
-        mat_name = maturity_data['maturity_name'].iloc[0]
-        results_df.loc[mat_name, 'a'] = float(a_scaled)
-        results_df.loc[mat_name, 'b'] = float(b_scaled)
-        results_df.loc[mat_name, 'm'] = float(m)
-        results_df.loc[mat_name, 'rho'] = float(rho)
-        results_df.loc[mat_name, 'sigma'] = float(sigma)
-        results_df.loc[mat_name, 'nu'] = float(nu)
-        results_df.loc[mat_name, 'psi'] = float(psi)
-        results_df.loc[mat_name, 'p'] = float(p)
-        results_df.loc[mat_name, 'c'] = float(c)
-        results_df.loc[mat_name, 'nu_tilde'] = float(nu_tilde)
-        results_df.loc[mat_name, 'rmse'] = float(rmse)
-        results_df.loc[mat_name, 'mae'] = float(mae)
-        results_df.loc[mat_name, 'r2'] = float(r2)
-        results_df.loc[mat_name, 'max_error'] = float(max_error)
-        results_df.loc[mat_name, 'log_min_strike'] = float(log_min_strike)
-        results_df.loc[mat_name, 'usd_min_strike'] = float(usd_min_strike)
-        results_df.loc[mat_name, 'butterfly_arbitrage_free'] = butterfly_arbitrage_free
-        results_df.loc[mat_name, 'fit_success'] = bool(not np.isnan(a))
-    else:
-        logger.warning(f"Skipping parameter update for maturity {mat2} due to invalid parameters")
-        mat_name = maturity_data['maturity_name'].iloc[0]
-        results_df.loc[mat_name, 'fit_success'] = False
+        results_df.at[mat2, 'a'] = float(a_scaled)
+        results_dfKILLat[mat2, 'b'] = float(b_scaled)
+        results_df.at[mat2, 'm'] = float(m)
+        results_df.at[mat2, 'rho'] = float(rho)
+        results_df.at[mat2, 'sigma'] = float(sigma)
+        results_df.at[mat2, 'nu'] = float(nu)
+        results_df.at[mat2, 'psi'] = float(psi)
+        results_df.at[mat2, 'p'] = float(p)
+        results_df.at[mat2, 'c'] = float(c)
+        results_df.at[mat2, 'nu_tilde'] = float(nu_tilde)
+        results_df.at[mat2, 'rmse'] = float(rmse)
+        results_df.at[mat2, 'mae'] = float(mae)
+        results_df.at[mat2, 'r2'] = float(r2)
+        results_df.at[mat2, 'max_error'] = float(max_error)
+        results_df.at[mat2, 'log_min_strike'] = float(log_min_strike)
+        results_df.at[mat2, 'usd_min_strike'] = float(usd_min_strike)
+        results_df.at[mat2, 'butterfly_arbitrage_free'] = butterfly_arbitrage_free
+        results_df.at[mat2, 'fit_success'] = bool(not np.isnan(a))
+    end_correction = time.time()
+    logger.info(f"Calendar arbitrage correction completed in {end_correction - start_correction:.4f} seconds")
 
     # Calendar arbitrage check (post-correction)
+    logger.info("\nChecking calendar arbitrage (post-correction)...")
+    start_post_check = time.time()
     calendar_arbitrage_free = True
     for i in range(len(sorted_maturities) - 1):
         mat1, mat2 = sorted_maturities[i], sorted_maturities[i + 1]
@@ -324,28 +330,29 @@ def fit_model(option_chain: pd.DataFrame) -> pd.DataFrame:
         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)]))
+        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)
+            w1 = SVIModel.svi_raw(k_val, a1 * t1, b1 * t1, m1, rho1, sigma1)
+            w2 = SVIModel.svi_raw(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
+    end_post_check = time.time()
+    logger.info(f"Post-correction calendar arbitrage check completed in {end_post_check - start_post_check:.4f} seconds")
 
-    for mat in results_df['maturity_date']:
-        results_df.loc[results_df['maturity_date'] == mat, 'calendar_arbitrage_free'] = calendar_arbitrage_free
+    for mat in sorted_maturities:
+        results_df.at[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 model fit: {end_total - start_total:.4f} seconds")
+    logger.info(f"\nTotal execution time for fit_model: {end_total - start_total:.4f} seconds")
 
-    logger.info("Model fitting complete.")
-    return results_df
+    logger.info("Model fitting and visualization complete.")
+    return results_df, params_dict
 
 
 @catch_exception
@@ -364,11 +371,11 @@ def get_iv_surface(model_results: pd.DataFrame,
 
     Returns:
     - Tuple of (iv_surface, x_surface)
-      iv_surface: Dictionary mapping maturity/dtm names to IV arrays
-      x_surface: Dictionary mapping maturity/dtm names to requested x domain arrays
+      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']
+    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}")
@@ -390,11 +397,11 @@ def get_iv_surface(model_results: pd.DataFrame,
             model_results.loc[i, 'sigma']
         ]
         s = model_results.loc[i, 's']
-        r = model_results.loc[i, 'r']
         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])
+        w = np.array([SVIModel.svi_raw(x, *params) for x in LM])
         o = np.sqrt(w / t)
         iv_surface[i] = o
 

{voly-0.0.195 → voly-0.0.196}/src/voly/models.py

@@ -35,6 +35,7 @@ class SVIModel:
 
     @staticmethod
     def svi(k, a, b, m, rho, sigma):
+        """Compute SVI total implied variance."""
         assert b >= 0 and abs(rho) <= 1 and sigma >= 0 and a + b * sigma * np.sqrt(1 - rho ** 2) >= 0
         return a + b * (rho * (k - m) + np.sqrt((k - m) ** 2 + sigma ** 2))
 
@@ -46,7 +47,7 @@ class SVIModel:
     @staticmethod
     def raw_to_jw_params(a: float, b: float, m: float, rho: float, sigma: float, t: float) -> Tuple[
         float, float, float, float, float]:
-        """Convert raw SVI parameters to Jump-Wing parameters."""
+        """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)
@@ -54,8 +55,15 @@ class SVIModel:
         nu_tilde = (1 / t) * (a + b * sigma * np.sqrt(1 - rho ** 2))
         return nu, psi, p, c, nu_tilde
 
+    @staticmethod
+    def loss(tiv, vega, y, c, d, a):
+        """Compute weighted mean squared error for calibration."""
+        diff = tiv - (a + d * y + c * np.sqrt(y * y + 1))
+        return (vega * diff * diff).mean()
+
     @classmethod
     def calibration(cls, tiv, vega, k, m, sigma):
+        """Calibrate c, d, a parameters given m and sigma."""
         sigma = max(sigma, 0.001)
         vega = vega / vega.max() if vega.max() > 0 else np.ones_like(vega)
         y = (k - m) / sigma
@@ -80,16 +88,11 @@ class SVIModel:
         loss = cls.loss(tiv, vega, y, c, d, a)
         return c, d, a, loss
 
-    @staticmethod
-    def loss(tiv, vega, y, c, d, a):
-        diff = tiv - (a + d * y + c * np.sqrt(y * y + 1))
-        return (vega * diff * diff).mean()
-
     @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)
@@ -100,7 +103,7 @@ class SVIModel:
             return loss
 
         result = minimize(score, [sigma_init, m_init], bounds=[(0.001, None), (None, None)],
-                         tol=1e-16, method="SLSQP", options={'maxfun': 5000})
+                          tol=1e-16, method="SLSQP", options={'maxfun': 5000})
 
         sigma, m = result.x
         c, d, a_calib, loss = cls.calibration(tiv, vega, k, m, sigma)
@@ -114,9 +117,7 @@ class SVIModel:
             a_svi = a_calib / tau
             rho_svi = b_svi = 0
 
-        # Validate parameters
-        params = [a_svi, b_svi, m, rho_svi, sigma]
-        return params, loss
+        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):
@@ -162,13 +163,12 @@ class SVIModel:
 
         if result.success:
             new_params = result.x
-            a, b, m, rho, sigma = new_params
-            a_scaled, b_scaled = a * t, b * t
-            w_current = cls.svi(k_constraint, a_scaled, b_scaled, m, rho, sigma)
+            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}")
+            logger.info(
+                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}")
         return params

{voly-0.0.195 → voly-0.0.196/src/voly.egg-info}/PKG-INFO

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