voly 0.0.81__py3-none-any.whl → 0.0.82__py3-none-any.whl

voly/client.py

@@ -420,6 +420,34 @@ class VolyClient:
 
         return plots
 
+    # -------------------------------------------------------------------------
+    # Interpolate
+    # -------------------------------------------------------------------------
+
+    @staticmethod
+    def interpolate_model(fit_results: pd.DataFrame,
+                          list_of_days: List[str] = ['7d', '30d', '90d', '150d', '240d'],
+                          method: str = 'cubic') -> pd.DataFrame:
+        """
+        Interpolate a fitted model to specific days to expiry.
+
+        Parameters:
+        - fit_results: DataFrame with fitting results from fit_model()
+        - list_of_days: List of specific days to include (e.g., ['7d', '30d', '90d'])
+        - method: Interpolation method ('linear', 'cubic', 'pchip', etc.)
+
+        Returns:
+        - DataFrame with interpolated model parameters for the specified days
+        """
+        logger.info(f"Interpolating model with {method} method")
+
+        # Interpolate the model
+        interpolated_results = interpolate_model(
+            fit_results, list_of_days, method
+        )
+
+        return interpolated_results
+
     # -------------------------------------------------------------------------
     # Risk-Neutral Density (RND)
     # -------------------------------------------------------------------------

voly/core/fit.py

@@ -93,6 +93,8 @@ def fit_model(option_chain: pd.DataFrame,
     # ANSI color codes for terminal output
     GREEN, RED, RESET = '\033[32m', '\033[31m', '\033[0m'
 
+    s = option_chain['index_price'].iloc[-1]
+
     for ytm in unique_ytms:
         # Get data for this maturity
         maturity_data = option_chain[option_chain['ytm'] == ytm]
@@ -128,7 +130,6 @@ def fit_model(option_chain: pd.DataFrame,
         max_error = np.max(np.abs(iv_market - iv_model))
 
         # Get or calculate additional required data
-        s = maturity_data['index_price'].iloc[0]
         u = maturity_data['underlying_price'].iloc[0]
 
         # Aggregate open interest and volume

voly/core/interpolate.py

@@ -1,221 +1,129 @@
 """
-Surface interpolation module for the Voly package.
+Model interpolation module for the Voly package.
 
-This module handles interpolation of implied volatility surfaces
-across both moneyness and time dimensions.
+This module handles interpolating volatility model parameters across different
+days to expiry, allowing for consistent volatility surfaces at arbitrary tenors.
 """
 
-import numpy as np
 import pandas as pd
-from typing import List, Tuple, Dict, Optional, Union, Any
-from scipy.interpolate import interp1d, pchip_interpolate
+import numpy as np
+import datetime as dt
+from typing import List, Dict, Tuple, Optional, Union, Any
+from scipy import interpolate
 from voly.utils.logger import logger, catch_exception
 from voly.exceptions import VolyError
-from voly.models import SVIModel
-
-
-@catch_exception
-def interpolate_surface_time(
-        moneyness_grid: np.ndarray,
-        expiries: np.ndarray,
-        surface_values: np.ndarray,
-        target_expiries: np.ndarray,
-        method: str = 'cubic'
-) -> np.ndarray:
-    """
-    Interpolate the surface across the time dimension.
-
-    Parameters:
-    - moneyness_grid: Array of log-moneyness values
-    - expiries: Array of expiry times (in years)
-    - surface_values: 2D array of values to interpolate (rows=expiries, cols=moneyness)
-    - target_expiries: Array of target expiry times to interpolate to
-    - method: Interpolation method ('linear', 'cubic', 'pchip', etc.)
-
-    Returns:
-    - 2D array of interpolated values (rows=target_expiries, cols=moneyness)
-    """
-    if len(expiries) < 2:
-        raise VolyError("At least two expiries are required for time interpolation")
-
-    # Initialize the output array
-    interpolated_surface = np.zeros((len(target_expiries), len(moneyness_grid)))
-
-    # For each moneyness point, interpolate across time
-    for i in range(len(moneyness_grid)):
-        if method == 'pchip':
-            # Use PCHIP (Piecewise Cubic Hermite Interpolating Polynomial)
-            interpolated_values = pchip_interpolate(expiries, surface_values[:, i], target_expiries)
-        else:
-            # Use regular interpolation (linear, cubic, etc.)
-            interp_func = interp1d(expiries, surface_values[:, i], kind=method, bounds_error=False,
-                                   fill_value='extrapolate')
-            interpolated_values = interp_func(target_expiries)
-
-        interpolated_surface[:, i] = interpolated_values
-
-    return interpolated_surface
-
-
-@catch_exception
-def create_target_expiries(
-        min_dte: float,
-        max_dte: float,
-        num_points: int = 10,
-        specific_days: Optional[List[int]] = None
-) -> np.ndarray:
-    """
-    Create a grid of target expiry days for interpolation.
-
-    Parameters:
-    - min_dte: Minimum days to expiry
-    - max_dte: Maximum days to expiry
-    - num_points: Number of points for regular grid
-    - specific_days: Optional list of specific days to include (e.g., [7, 30, 90, 180])
-
-    Returns:
-    - Array of target expiry times in years
-    """
-    # Create regular grid in days
-    if specific_days is not None:
-        # Filter specific days to be within range
-        days = np.array([d for d in specific_days if min_dte <= d <= max_dte])
-        if len(days) == 0:
-            logger.warning("No specific days within range, using regular grid")
-            days = np.linspace(min_dte, max_dte, num_points)
-    else:
-        # Use regular grid
-        days = np.linspace(min_dte, max_dte, num_points)
-
-    # Convert to years
-    years = days / 365.25
-
-    return years
-
-
-@catch_exception
-def interpolate_svi_parameters(
-        raw_param_matrix: pd.DataFrame,
-        target_expiries_years: np.ndarray,
-        method: str = 'cubic'
-) -> pd.DataFrame:
-    """
-    Interpolate SVI parameters across time.
-
-    Parameters:
-    - raw_param_matrix: Matrix of SVI parameters with maturity names as columns
-    - target_expiries_years: Array of target expiry times (in years)
-    - method: Interpolation method ('linear', 'cubic', 'pchip', etc.)
-
-    Returns:
-    - Matrix of interpolated SVI parameters
-    """
-    # Get expiry times in years from the parameter matrix
-    yte_values = raw_param_matrix.attrs['yte_values']
-    dte_values = raw_param_matrix.attrs['dte_values']
-
-    # Sort maturity names by DTE
-    maturity_names = sorted(yte_values.keys(), key=lambda x: dte_values[x])
-
-    # Extract expiry times in order
-    expiry_years = np.array([yte_values[m] for m in maturity_names])
-
-    # Check if we have enough points for interpolation
-    if len(expiry_years) < 2:
-        raise VolyError("At least two expiries are required for interpolation")
-
-    # Create new parameter matrix for interpolated values
-    interp_param_matrix = pd.DataFrame(
-        columns=[f"t{i:.2f}" for i in target_expiries_years],
-        index=SVIModel.PARAM_NAMES
-    )
-
-    # For each SVI parameter, interpolate across time
-    for param in SVIModel.PARAM_NAMES:
-        param_values = np.array([raw_param_matrix.loc[param, m] for m in maturity_names])
-
-        if method == 'pchip':
-            interpolated_values = pchip_interpolate(expiry_years, param_values, target_expiries_years)
-        else:
-            interp_func = interp1d(expiry_years, param_values, kind=method, bounds_error=False,
-                                   fill_value='extrapolate')
-            interpolated_values = interp_func(target_expiries_years)
-
-        # Store interpolated values
-        for i, t in enumerate(target_expiries_years):
-            interp_param_matrix.loc[param, f"t{t:.2f}"] = interpolated_values[i]
-
-    # Create matching DTE values for convenience
-    interp_dte_values = target_expiries_years * 365.25
-
-    # Store YTE and DTE as attributes in the DataFrame for reference
-    interp_param_matrix.attrs['yte_values'] = {f"t{t:.2f}": t for t in target_expiries_years}
-    interp_param_matrix.attrs['dte_values'] = {f"t{t:.2f}": t * 365.25 for t in target_expiries_years}
-
-    return interp_param_matrix
 
 
 @catch_exception
-def interpolate_model(
-        fit_results: Dict[str, Any],
-        specific_days: Optional[List[int]] = None,
-        num_points: int = 10,
-        method: str = 'cubic'
-) -> Dict[str, Any]:
+def interpolate_model(fit_results: pd.DataFrame,
+                      list_of_days: List[str] = ['7d', '30d', '90d', '150d', '240d'],
+                      method: str = 'cubic') -> pd.DataFrame:
     """
-    Interpolate a fitted model to specific days to expiry.
+    Interpolate model parameters across different days to expiry.
 
     Parameters:
-    - fit_results: Dictionary with fitting results from fit_model()
-    - specific_days: Optional list of specific days to include (e.g., [7, 30, 90, 180])
-    - num_points: Number of points for regular grid if specific_days is None
+    - fit_results: DataFrame with model fitting results, indexed by maturity names
+    - list_of_days: list of specific days to interpolate to (e.g., ['7d', '30d', '90d'])
     - method: Interpolation method ('linear', 'cubic', 'pchip', etc.)
 
     Returns:
-    - Dictionary with interpolation results
+    - DataFrame with interpolated model parameters for the specified days
     """
-    # Extract required data from fit results
-    raw_param_matrix = fit_results['raw_param_matrix']
-    moneyness_grid = fit_results['moneyness_grid']
-
-    # Get min and max DTE from the original data
-    dte_values = list(raw_param_matrix.attrs['dte_values'].values())
-    min_dte = min(dte_values)
-    max_dte = max(dte_values)
-
-    # Create target expiry grid
-    target_expiries_years = create_target_expiries(min_dte, max_dte, num_points, specific_days)
-
-    # Interpolate SVI parameters
-    interp_param_matrix = interpolate_svi_parameters(raw_param_matrix, target_expiries_years, method)
-
-    # Generate implied volatility surface from interpolated parameters
-    iv_surface = {}
-    for maturity_name, yte in interp_param_matrix.attrs['yte_values'].items():
-        svi_params = interp_param_matrix[maturity_name].values
-        w_svi = [SVIModel.svi(x, *svi_params) for x in moneyness_grid]
-        iv_surface[yte] = np.sqrt(np.array(w_svi) / yte)
-
-    # Convert to Jump-Wing parameters for the interpolated maturities
-    jw_param_matrix = pd.DataFrame(
-        columns=interp_param_matrix.columns,
-        index=SVIModel.JW_PARAM_NAMES
-    )
-
-    for maturity_name, yte in interp_param_matrix.attrs['yte_values'].items():
-        a, b, sigma, rho, m = interp_param_matrix[maturity_name].values
-        nu, psi, p, c, nu_tilde = SVIModel.svi_jw_params(a, b, sigma, rho, m, yte)
-        jw_param_matrix[maturity_name] = [nu, psi, p, c, nu_tilde]
-
-    # Copy attributes from param matrix
-    jw_param_matrix.attrs = interp_param_matrix.attrs.copy()
-
-    return {
-        'moneyness_grid': moneyness_grid,
-        'target_expiries_years': target_expiries_years,
-        'target_expiries_days': target_expiries_years * 365.25,
-        'interp_param_matrix': interp_param_matrix,
-        'interp_jw_param_matrix': jw_param_matrix,
-        'iv_surface': iv_surface,
-        'method': method
-    }
+    logger.info(f"Interpolating model parameters using {method} method")
+
+    # Check if fit_results is valid
+    if fit_results is None or fit_results.empty:
+        raise VolyError("Fit results DataFrame is empty or None")
+
+    # Extract years to maturity from fit_results
+    original_ytms = fit_results['ytm'].values
+
+    if len(original_ytms) < 2:
+        raise VolyError("Need at least two maturities in fit_results to interpolate")
+
+    # Sort original years to maturity for proper interpolation
+    sorted_indices = np.argsort(original_ytms)
+    original_ytms = original_ytms[sorted_indices]
+
+    # Parse days from strings like '7d', '30d', etc.
+    target_days = []
+    for day_str in list_of_days:
+        if not day_str.endswith('d'):
+            raise VolyError(f"Invalid day format: {day_str}. Expected format: '7d', '30d', etc.")
+        try:
+            days = int(day_str[:-1])
+            target_days.append(days)
+        except ValueError:
+            raise VolyError(f"Invalid day value: {day_str}. Expected format: '7d', '30d', etc.")
+
+    # Convert target days to years for interpolation (to match original implementation)
+    target_years = [day / 365.25 for day in target_days]
+
+    # Check if target years are within the range of original years
+    min_original, max_original = np.min(original_ytms), np.max(original_ytms)
+    for years in target_years:
+        if years < min_original or years > max_original:
+            logger.warning(
+                f"Target time {years:.4f} years is outside the range of original data [{min_original:.4f}, {max_original:.4f}]. "
+                "Extrapolation may give unreliable results.")
+
+    # Columns to interpolate
+    param_columns = ['u', 'a', 'b', 'rho', 'm', 'sigma', 'nu', 'psi', 'p', 'c', 'nu_tilde']
+
+    # Create empty DataFrame for interpolated results
+    interpolated_df = pd.DataFrame(index=[f"{day}d" for day in target_days])
+
+    # Generate YTM and maturity dates for interpolated results
+    interpolated_df['dtm'] = target_days
+    interpolated_df['ytm'] = [day / 365.25 for day in target_days]
+
+    # Calculate maturity dates
+    now = dt.datetime.now()
+    maturity_dates = []
+    for days in target_days:
+        maturity_date = now + dt.timedelta(days=days)
+        maturity_dates.append(maturity_date)
+
+    interpolated_df['maturity_date'] = maturity_dates
+
+    # Sort fit_results by ytm
+    sorted_fit_results = fit_results.iloc[sorted_indices]
+
+    # Interpolate model parameters
+    for param in param_columns:
+        if param in fit_results.columns:
+            try:
+                # Create interpolation function using years to expiry
+                f = interpolate.interp1d(
+                    original_ytms,
+                    sorted_fit_results[param].values,
+                    kind=method,
+                    bounds_error=False,
+                    fill_value='extrapolate'
+                )
+
+                # Apply interpolation with target years
+                interpolated_df[param] = f(target_years)
+            except Exception as e:
+                logger.error(f"Error interpolating parameter {param}: {str(e)}")
+                # Fallback to nearest neighbor if sophisticated method fails
+                f = interpolate.interp1d(
+                    original_ytms,
+                    sorted_fit_results[param].values,
+                    kind='nearest',
+                    bounds_error=False,
+                    fill_value=(sorted_fit_results[param].iloc[0], sorted_fit_results[param].iloc[-1])
+                )
+                interpolated_df[param] = f(target_years)
+
+    # Ensure consistent ordering of columns with expected structure
+    expected_columns = ['u', 'maturity_date', 'dtm', 'ytm', 'a', 'b', 'rho', 'm', 'sigma',
+                        'nu', 'psi', 'p', 'c', 'nu_tilde']
+
+    # Create final column order based on available columns
+    column_order = [col for col in expected_columns if col in interpolated_df.columns]
+    interpolated_df = interpolated_df[column_order]
+
+    logger.info(f"Successfully interpolated model parameters for {len(target_days)} target days")
+
+    return interpolated_df

{voly-0.0.81.dist-info → voly-0.0.82.dist-info}/METADATA

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

{voly-0.0.81.dist-info → voly-0.0.82.dist-info}/RECORD

@@ -1,18 +1,18 @@
 voly/__init__.py,sha256=8xyDk7rFCn_MOD5hxuv5cxxKZvBVRiSIM7TgaMPpwpw,211
-voly/client.py,sha256=lAxjRgSNsVBZiM53SJxLdCPOugBf5utMMCk65E7NY8A,20745
+voly/client.py,sha256=Y6XidftiRTiFHuckv9HT8EyApF6zDjR14mryZeO0rGA,21828
 voly/exceptions.py,sha256=PBsbn1vNMvKcCJwwJ4lBO6glD85jo1h2qiEmD7ArAjs,92
 voly/formulas.py,sha256=wSbGAH6GuQThT9QyQY4Ud2eUf9fo1YFHglUmP6fNris,11871
 voly/models.py,sha256=LXXIlpXZQEfXTuCngxC8Hd3bWtw6wdXDCSGxTLmHM-c,3659
 voly/core/__init__.py,sha256=bu6fS2I1Pj9fPPnl-zY3L7NqrZSY5Zy6NY2uMUvdhKs,183
 voly/core/charts.py,sha256=ycZgbPeROYVRMO61auVXCGLmKZA2NwS3vLOsQ9wqCyo,27526
 voly/core/data.py,sha256=JCPD44UDSJqh83jjapAtXVpJEHm8Hq4JC8lVhl5Zb4A,8935
-voly/core/fit.py,sha256=JOr2XjM-I9HtfbyEN0tdGuNCZimQ2ttm4lNUpF-tKb4,9226
-voly/core/interpolate.py,sha256=ztVIePJZOh-CIbn69wkh1JW2rKywNe2FEewRN0zcSAo,8185
+voly/core/fit.py,sha256=lDlw4z5lehJSgpT4-J7NLq3wf42sQQM-0GHSlaATGKA,9223
+voly/core/interpolate.py,sha256=7FBx7EmbgET1I1-MD6o-nxCyGlAqcQJulCXYvzATisU,5243
 voly/core/rnd.py,sha256=8FTU-Qp9epW9yE4XSOdiFGIRXrGyXqF6mVgZn1NMvxk,11813
 voly/utils/__init__.py,sha256=E05mWatyC-PDOsCxQV1p5Xi1IgpOomxrNURyCx_gB-w,200
 voly/utils/logger.py,sha256=4-_2bVJmq17Q0d7Rd2mPg1AeR8gxv6EPvcmBDMFWcSM,1744
-voly-0.0.81.dist-info/LICENSE,sha256=wcHIVbE12jfcBOai_wqBKY6xvNQU5E909xL1zZNq_2Q,1065
-voly-0.0.81.dist-info/METADATA,sha256=zyXi0_UMkVxYEZ8ulpMGTtTcx_ij-LEcONdb5TbXBHM,4092
-voly-0.0.81.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
-voly-0.0.81.dist-info/top_level.txt,sha256=ZfLw2sSxF-LrKAkgGjOmeTcw6_gD-30zvtdEY5W4B7c,5
-voly-0.0.81.dist-info/RECORD,,
+voly-0.0.82.dist-info/LICENSE,sha256=wcHIVbE12jfcBOai_wqBKY6xvNQU5E909xL1zZNq_2Q,1065
+voly-0.0.82.dist-info/METADATA,sha256=uV23GWgeNRpVdmu6psFoJdeJJ7v1CwpoBL-C720BJnQ,4092
+voly-0.0.82.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
+voly-0.0.82.dist-info/top_level.txt,sha256=ZfLw2sSxF-LrKAkgGjOmeTcw6_gD-30zvtdEY5W4B7c,5
+voly-0.0.82.dist-info/RECORD,,