voly 0.0.81__tar.gz → 0.0.83__tar.gz

{voly-0.0.81/src/voly.egg-info → voly-0.0.83}/PKG-INFO

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

{voly-0.0.81 → voly-0.0.83}/pyproject.toml

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

{voly-0.0.81 → voly-0.0.83}/src/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-0.0.81 → voly-0.0.83}/src/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
@@ -187,14 +188,16 @@ def fit_model(option_chain: pd.DataFrame,
 
 
 @catch_exception
-def get_iv_surface(fit_results: pd.DataFrame,
+def get_iv_surface(model_results: pd.DataFrame,
                    log_moneyness_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:
-    - fit_results: DataFrame from fit_model() with maturity names as index
+    - model_results: DataFrame from fit_model() or interpolate_model()
     - log_moneyness_params: Tuple of (min, max, num_points) for the moneyness grid
     - return_domain: Domain for x-axis values ('log_moneyness', 'moneyness', 'strikes', 'delta')
 
@@ -203,6 +206,11 @@ def get_iv_surface(fit_results: pd.DataFrame,
       iv_surface: Dictionary mapping maturity names to IV arrays
       x_surface: Dictionary mapping maturity names to requested x domain arrays
     """
+    # Check if required columns are present
+    required_columns = ['a', 'b', 'rho', 'm', 'sigma', 'ytm']
+    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
     min_m, max_m, num_points = log_moneyness_params
@@ -212,16 +220,16 @@ def get_iv_surface(fit_results: pd.DataFrame,
     x_surface = {}
 
     # Process each maturity
-    for maturity in fit_results.index:
+    for i in model_results.index:
         # Calculate SVI total implied variance and convert to IV
         params = [
-            fit_results.loc[maturity, 'a'],
-            fit_results.loc[maturity, 'b'],
-            fit_results.loc[maturity, 'sigma'],
-            fit_results.loc[maturity, 'rho'],
-            fit_results.loc[maturity, 'm']
+            fit_results.loc[i, 'a'],
+            fit_results.loc[i, 'b'],
+            fit_results.loc[i, 'sigma'],
+            fit_results.loc[i, 'rho'],
+            fit_results.loc[i, 'm']
         ]
-        ytm = fit_results.loc[maturity, 'ytm']
+        ytm = fit_results.loc[i, 'ytm']
 
         # Calculate implied volatility
         w_svi = np.array([SVIModel.svi(x, *params) for x in log_moneyness_array])
@@ -232,8 +240,8 @@ def get_iv_surface(fit_results: pd.DataFrame,
         x_surface[maturity] = get_x_domain(
             log_moneyness_params=log_moneyness_params,
             return_domain=return_domain,
-            s=fit_results.loc[maturity, 's'],
-            r=fit_results.loc[maturity, 'r'],
+            s=fit_results.loc[i, 's'],
+            r=fit_results.loc[i, 'r'],
             iv_array=iv_array,
             ytm=ytm
         )

voly-0.0.83/src/voly/core/interpolate.py

@@ -0,0 +1,132 @@
+"""
+Model interpolation module for the Voly package.
+
+This module handles interpolating volatility model parameters across different
+days to expiry, allowing for consistent volatility surfaces at arbitrary tenors.
+"""
+
+import pandas as pd
+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
+
+
+@catch_exception
+def interpolate_model(fit_results: pd.DataFrame,
+                      list_of_days: List[str] = ['7d', '30d', '90d', '150d', '240d'],
+                      method: str = 'cubic') -> pd.DataFrame:
+    """
+    Interpolate model parameters across different days to expiry.
+
+    Parameters:
+    - 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:
+    - DataFrame with interpolated model parameters for the specified days
+    """
+    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]
+    recent_row = sorted_fit_results.iloc[-1]
+    interpolated_df['s'] = recent_row['s']
+    interpolated_df['r'] = recent_row['r']
+
+    # 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 = ['s', 'u', 'maturity_date', 'dtm', 'ytm', 'a', 'b', 'rho', 'm', 'sigma',
+                        'nu', 'psi', 'p', 'c', 'nu_tilde', 'r']
+
+    # 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 → voly-0.0.83/src/voly.egg-info}/PKG-INFO

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

voly-0.0.81/src/voly/core/interpolate.py

@@ -1,221 +0,0 @@
-"""
-Surface interpolation module for the Voly package.
-
-This module handles interpolation of implied volatility surfaces
-across both moneyness and time dimensions.
-"""
-
-import numpy as np
-import pandas as pd
-from typing import List, Tuple, Dict, Optional, Union, Any
-from scipy.interpolate import interp1d, pchip_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]:
-    """
-    Interpolate a fitted model to specific 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
-    - method: Interpolation method ('linear', 'cubic', 'pchip', etc.)
-
-    Returns:
-    - Dictionary with interpolation results
-    """
-    # 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
-    }