voly 0.0.57__py3-none-any.whl → 0.0.59__py3-none-any.whl

voly/core/charts.py

@@ -13,9 +13,6 @@ from voly.models import SVIModel
 import plotly.graph_objects as go
 from plotly.subplots import make_subplots
 import plotly.io as pio
-import plotly.express as px
-from plotly.colors import hex_to_rgb, make_colorscale
-
 
 # Set default renderer to browser for interactive plots
 pio.renderers.default = "browser"
@@ -25,20 +22,8 @@ pio.renderers.default = "browser"
 def plot_volatility_smile(moneyness_array: np.ndarray,
                           iv_array: np.ndarray,
                           market_data: pd.DataFrame = None,
-                          maturity: Optional[float] = None,
-                          ) -> go.Figure:
-    """
-    Plot volatility smile for a single expiry.
-
-    Parameters:
-    - moneyness_array: Moneyness grid
-    - iv_array: Implied volatility values
-    - market_data: Optional market data for comparison
-    - maturity: Maturity name for filtering market data
-
-    Returns:
-    - Plotly figure
-    """
+                          maturity: Optional[str] = None) -> go.Figure:
+    """Plot volatility smile for a single expiry."""
     fig = go.Figure()
 
     # Add model curve
@@ -52,289 +37,218 @@ def plot_volatility_smile(moneyness_array: np.ndarray,
         )
     )
 
-    # Filter market data for the specific expiry
-    maturity_data = market_data[market_data['maturity_name'] == maturity]
-
-    if not maturity_data.empty:
-        # Add bid IV
-        fig.add_trace(
-            go.Scatter(
-                x=maturity_data['log_moneyness'],
-                y=maturity_data['bid_iv'] * 100,  # Convert to percentage
-                mode='markers',
-                name='Bid IV',
-                marker=dict(size=8, symbol='circle', opacity=0.7)
+    # Add market data if provided
+    if market_data is not None and maturity is not None:
+        maturity_data = market_data[market_data['maturity_name'] == maturity]
+
+        if not maturity_data.empty:
+            # Add bid and ask IVs
+            for iv_type in ['bid_iv', 'ask_iv']:
+                if iv_type in maturity_data.columns:
+                    fig.add_trace(
+                        go.Scatter(
+                            x=maturity_data['log_moneyness'],
+                            y=maturity_data[iv_type] * 100,  # Convert to percentage
+                            mode='markers',
+                            name=iv_type.replace('_', ' ').upper(),
+                            marker=dict(size=8, symbol='circle', opacity=0.7)
+                        )
+                    )
+
+            dte_value = maturity_data['dtm'].iloc[0]
+
+            # Update layout
+            fig.update_layout(
+                title=f'Vol Smile for {maturity} (DTE: {dte_value:.1f})',
+                xaxis_title='Log Moneyness',
+                yaxis_title='Implied Volatility (%)',
+                template='plotly_dark',
+                legend=dict(orientation='h', yanchor='bottom', y=1.02, xanchor='right', x=1)
             )
-        )
-
-        # Add ask IV
-        fig.add_trace(
-            go.Scatter(
-                x=maturity_data['log_moneyness'],
-                y=maturity_data['ask_iv'] * 100,  # Convert to percentage
-                mode='markers',
-                name='Ask IV',
-                marker=dict(size=8, symbol='circle', opacity=0.7)
-            )
-        )
-
-    dte_value = maturity_data['dte'].iloc[0]
-
-    # Update layout
-    fig.update_layout(
-        title=f'Vol Smile for {maturity} (DTE: {dte_value:.1f})',
-        xaxis_title='Log Moneyness',
-        yaxis_title='Implied Volatility (%)',
-        template='plotly_dark',
-        legend=dict(orientation='h', yanchor='bottom', y=1.02, xanchor='right', x=1)
-    )
 
     return fig
 
 
 @catch_exception
 def plot_all_smiles(moneyness_array: np.ndarray,
-                    iv_surface: Dict[float, np.ndarray],
+                    iv_surface: Dict[str, np.ndarray],
                     market_data: Optional[pd.DataFrame] = None) -> List[go.Figure]:
-    """
-    Plot volatility smiles for all expiries.
-
-    Parameters:
-    - moneyness: Moneyness grid
-    - iv_surface: Dictionary mapping expiry times to IV arrays
-    - market_data: Optional market data for comparison
-
-    Returns:
-    - List of Plotly figures
-    """
-    figures = []
-
-    # Get maturities
-    maturities = list(iv_surface.keys())
-
-    # Create a figure for each expiry
-    for maturity in maturities:
-        fig = plot_volatility_smile(
+    """Plot volatility smiles for all expiries."""
+    return [
+        plot_volatility_smile(
             moneyness_array=moneyness_array,
             iv_array=iv_surface[maturity],
             market_data=market_data,
             maturity=maturity
         )
-        figures.append(fig)
-
-    return figures
+        for maturity in iv_surface.keys()
+    ]
 
 
 @catch_exception
-def plot_parameters(raw_param_matrix: pd.DataFrame,
-                    jw_param_matrix: Optional[pd.DataFrame] = None) -> Tuple[go.Figure, Optional[go.Figure]]:
-    """
-    Plot model parameters across different expiries.
-
-    Parameters:
-    - raw_param_matrix: Matrix of raw SVI parameters with maturity names as columns
-    - jw_param_matrix: Optional matrix of Jump-Wing parameters
-
-    Returns:
-    - Tuple of Plotly figures (raw_params_fig, jw_params_fig)
-    """
-    # Plot raw SVI parameters
-    param_names = raw_param_matrix.index
-    raw_fig = make_subplots(rows=3, cols=2, subplot_titles=[f"Parameter {p}: {SVIModel.PARAM_DESCRIPTIONS.get(p, '')}"
-                                                            for p in param_names] + [''])
-
-    # Get maturity names (columns) in order
-    maturity_names = raw_param_matrix.columns
+def plot_parameters(fit_results: pd.DataFrame) -> go.Figure:
+    """Plot raw SVI parameters across different expiries."""
+    # Select parameters to plot
+    param_names = ['a', 'b', 'sigma', 'rho', 'm']
 
-    # Get YTE and DTE values from attributes
-    yte_values = raw_param_matrix.attrs['yte_values']
-    dte_values = raw_param_matrix.attrs['dte_values']
+    # Create subplots
+    fig = make_subplots(
+        rows=3, cols=2,
+        subplot_titles=[f"Parameter {p}: {SVIModel.PARAM_DESCRIPTIONS.get(p, '')}"
+                        for p in param_names] + ['']
+    )
 
-    # Create custom x-axis tick labels
-    tick_labels = [f"{m} (DTE: {dte_values[m]:.1f}, YTE: {yte_values[m]:.4f})" for m in maturity_names]
+    # Get maturity names and prepare tick labels
+    maturity_names = fit_results.columns
+    tick_labels = [f"{m} (DTE: {fit_results.loc['dtm', m]:.1f})" for m in maturity_names]
 
     # Plot each parameter
     for i, param in enumerate(param_names):
-        row = i // 2 + 1
-        col = i % 2 + 1
+        row, col = (i // 2) + 1, (i % 2) + 1
 
-        raw_fig.add_trace(
+        fig.add_trace(
             go.Scatter(
-                x=list(range(len(maturity_names))),  # Use indices for x-axis positioning
-                y=raw_param_matrix.loc[param],
+                x=list(range(len(maturity_names))),
+                y=fit_results.loc[param],
                 mode='lines+markers',
                 name=param,
                 line=dict(width=2),
                 marker=dict(size=8),
-                text=tick_labels,  # Add hover text
+                text=tick_labels,
                 hovertemplate="%{text}<br>%{y:.4f}"
             ),
             row=row, col=col
         )
 
-        # Update x-axis for this subplot with custom tick labels
-        raw_fig.update_xaxes(
+        # Set x-axis labels
+        fig.update_xaxes(
             tickvals=list(range(len(maturity_names))),
             ticktext=maturity_names,
             tickangle=45,
             row=row, col=col
         )
 
-    # Update layout for raw parameters
-    raw_fig.update_layout(
+    # Update layout
+    fig.update_layout(
         title='Raw SVI Parameters Across Expiries',
         template='plotly_dark',
         showlegend=False,
-        height=800
     )
 
-    # Plot Jump-Wing parameters if provided
-    jw_fig = None
-    if jw_param_matrix is not None:
-        jw_param_names = jw_param_matrix.index
-        jw_fig = make_subplots(rows=3, cols=2,
-                               subplot_titles=[f"Parameter {p}: {SVIModel.PARAM_DESCRIPTIONS.get(p, '')}"
-                                               for p in jw_param_names] + [''])
-
-        # Plot each JW parameter
-        for i, param in enumerate(jw_param_names):
-            row = i // 2 + 1
-            col = i % 2 + 1
-
-            jw_fig.add_trace(
-                go.Scatter(
-                    x=list(range(len(maturity_names))),  # Use indices for x-axis positioning
-                    y=jw_param_matrix.loc[param],
-                    mode='lines+markers',
-                    name=param,
-                    line=dict(width=2, color='rgb(0, 180, 180)'),
-                    marker=dict(size=8),
-                    text=tick_labels,  # Add hover text
-                    hovertemplate="%{text}<br>%{y:.4f}"
-                ),
-                row=row, col=col
-            )
+    return fig
 
-            # Update x-axis for this subplot with custom tick labels
-            jw_fig.update_xaxes(
-                tickvals=list(range(len(maturity_names))),
-                ticktext=maturity_names,
-                tickangle=45,
-                row=row, col=col
-            )
 
-        # Update layout for JW parameters
-        jw_fig.update_layout(
-            title='Jump-Wing Parameters Across Expiries',
-            template='plotly_dark',
-            showlegend=False,
-            height=800
-        )
+@catch_exception
+def plot_jw_parameters(fit_results: pd.DataFrame) -> go.Figure:
+    """Plot Jump-Wing parameters across different expiries."""
+    # Select parameters to plot
+    param_names = ['nu', 'psi', 'p', 'c', 'nu_tilde']
 
-    return raw_fig, jw_fig
+    # Create subplots
+    fig = make_subplots(
+        rows=3, cols=2,
+        subplot_titles=[f"Parameter {p}: {SVIModel.PARAM_DESCRIPTIONS.get(p, '')}"
+                        for p in param_names] + ['']
+    )
 
+    # Get maturity names and prepare tick labels
+    maturity_names = fit_results.columns
+    tick_labels = [f"{m} (DTE: {fit_results.loc['dtm', m]:.1f})" for m in maturity_names]
 
-@catch_exception
-def plot_fit_performance(fit_performance: pd.DataFrame) -> go.Figure:
-    """
-    Plot the fitting accuracy statistics.
+    # Plot each parameter
+    for i, param in enumerate(param_names):
+        row, col = (i // 2) + 1, (i % 2) + 1
 
-    Parameters:
-    - stats_df: DataFrame with fitting statistics
+        fig.add_trace(
+            go.Scatter(
+                x=list(range(len(maturity_names))),
+                y=fit_results.loc[param],
+                mode='lines+markers',
+                name=param,
+                line=dict(width=2, color='rgb(0, 180, 180)'),
+                marker=dict(size=8),
+                text=tick_labels,
+                hovertemplate="%{text}<br>%{y:.4f}"
+            ),
+            row=row, col=col
+        )
 
-    Returns:
-    - Plotly figure
-    """
-    fig = make_subplots(
-        rows=2, cols=2,
-        subplot_titles=['RMSE by Expiry', 'MAE by Expiry',
-                        'R² by Expiry', 'Max Error by Expiry']
+        # Set x-axis labels
+        fig.update_xaxes(
+            tickvals=list(range(len(maturity_names))),
+            ticktext=maturity_names,
+            tickangle=45,
+            row=row, col=col
+        )
+
+    # Update layout
+    fig.update_layout(
+        title='Jump-Wing Parameters Across Expiries',
+        template='plotly_dark',
+        showlegend=False,
     )
 
-    # Create custom tick labels with maturity name, DTE, and YTE
-    tick_labels = [f"{m} (DTE: {d:.1f})" for m, d in
-                   zip(fit_performance['Maturity'], fit_performance['DTE'])]
+    return fig
 
-    # Get x-axis values for plotting (use indices for positioning)
-    x_indices = list(range(len(fit_performance)))
 
-    # Plot RMSE
-    fig.add_trace(
-        go.Scatter(
-            x=x_indices,
-            y=fit_performance['RMSE'] * 100,  # Convert to percentage
-            mode='lines+markers',
-            name='RMSE',
-            line=dict(width=2),
-            marker=dict(size=8),
-            text=tick_labels  # Add hover text
-        ),
-        row=1, col=1
+@catch_exception
+def plot_fit_performance(fit_performance: pd.DataFrame) -> go.Figure:
+    """Plot the fitting accuracy statistics."""
+    # Define metrics to plot
+    metrics = {
+        'rmse': {'title': 'RMSE by Expiry', 'row': 1, 'col': 1, 'ylabel': 'RMSE (%)', 'scale': 100},
+        'mae': {'title': 'MAE by Expiry', 'row': 1, 'col': 2, 'ylabel': 'MAE (%)', 'scale': 100},
+        'r2': {'title': 'R² by Expiry', 'row': 2, 'col': 1, 'ylabel': 'R²', 'scale': 1},
+        'max_error': {'title': 'Max Error by Expiry', 'row': 2, 'col': 2, 'ylabel': 'Max Error (%)', 'scale': 100}
+    }
+
+    # Create subplots
+    fig = make_subplots(
+        rows=2, cols=2,
+        subplot_titles=[metrics[m]['title'] for m in metrics]
     )
 
-    # Plot MAE
-    fig.add_trace(
-        go.Scatter(
-            x=x_indices,
-            y=fit_performance['MAE'] * 100,  # Convert to percentage
-            mode='lines+markers',
-            name='MAE',
-            line=dict(width=2),
-            marker=dict(size=8),
-            text=tick_labels  # Add hover text
-        ),
-        row=1, col=2
-    )
+    # Get maturity names and create x-axis indices
+    maturity_names = fit_performance.columns
+    x_indices = list(range(len(maturity_names)))
 
-    # Plot R²
-    fig.add_trace(
-        go.Scatter(
-            x=x_indices,
-            y=fit_performance['R²'],
-            mode='lines+markers',
-            name='R²',
-            line=dict(width=2),
-            marker=dict(size=8),
-            text=tick_labels  # Add hover text
-        ),
-        row=2, col=1
-    )
+    # Create hover labels
+    hover_labels = [f"{m}" for m in maturity_names]
 
-    # Plot Max Error
-    fig.add_trace(
-        go.Scatter(
-            x=x_indices,
-            y=fit_performance['Max Error'] * 100,  # Convert to percentage
-            mode='lines+markers',
-            name='Max Error',
-            line=dict(width=2),
-            marker=dict(size=8),
-            text=tick_labels  # Add hover text
-        ),
-        row=2, col=2
-    )
+    # Plot each metric
+    for metric, config in metrics.items():
+        fig.add_trace(
+            go.Scatter(
+                x=x_indices,
+                y=fit_performance.loc[metric] * config['scale'],
+                mode='lines+markers',
+                name=metric.upper(),
+                line=dict(width=2),
+                marker=dict(size=8),
+                text=hover_labels,
+                hovertemplate="%{text}<br>%{y:.4f}"
+            ),
+            row=config['row'], col=config['col']
+        )
+
+        # Update axes
+        fig.update_yaxes(title_text=config['ylabel'], row=config['row'], col=config['col'])
 
-    # Update x-axis for all subplots with maturity names
+    # Set x-axis labels for all subplots
     for row in range(1, 3):
         for col in range(1, 3):
             fig.update_xaxes(
                 tickvals=x_indices,
-                ticktext=fit_performance['Maturity'],
+                ticktext=maturity_names,
                 tickangle=45,
                 row=row, col=col
             )
 
-    # Update y-axis titles
-    fig.update_yaxes(title_text='RMSE (%)', row=1, col=1)
-    fig.update_yaxes(title_text='MAE (%)', row=1, col=2)
-    fig.update_yaxes(title_text='R²', row=2, col=1)
-    fig.update_yaxes(title_text='Max Error (%)', row=2, col=2)
-
     # Update layout
     fig.update_layout(
         title='Model Fitting Accuracy Statistics',
         template='plotly_dark',
-        showlegend=False
+        showlegend=False,
     )
 
     return fig
@@ -342,35 +256,42 @@ def plot_fit_performance(fit_performance: pd.DataFrame) -> go.Figure:
 
 @catch_exception
 def plot_3d_surface(moneyness_array: np.ndarray,
-                    iv_surface: dict[float, np.ndarray]) -> go.Figure:
-    """
-    Plot 3D implied volatility surface.
+                    iv_surface: Dict[str, np.ndarray],
+                    fit_results: pd.DataFrame = None) -> go.Figure:
+    """Plot 3D implied volatility surface."""
+    # Define custom colorscale
+    custom_blue_scale = [[0, '#60AEFC'], [1, '#002040']]
+
+    # Get maturity names
+    maturity_names = list(iv_surface.keys())
+
+    # Get z-axis values (days to expiry)
+    if fit_results is not None:
+        # Use DTM values from fit_results
+        maturity_values = [fit_results.loc['dtm', name] for name in maturity_names]
+    else:
+        # Default to sequential values
+        maturity_values = list(range(len(maturity_names)))
+
+    # Create 3D surface data
+    z_array = np.array([iv_surface[m] * 100 for m in maturity_names])  # Convert to percentage
+    X, Y = np.meshgrid(moneyness_array, maturity_values)
 
-    Parameters:
-    - moneyness_array: grid of moneyness values
-    - iv_surface: Dictionary mapping expiry times to IV arrays
-
-    Returns:
-    - Plotly figure
-    """
-    start_color = '#60AEFC'
-    end_color = '#002040'  # Darker blue
-    custom_blue_scale = [[0, start_color], [1, end_color]]
-    maturities = list(iv_surface.keys())
-
-    # Convert implied volatility surface to array
-    z_array = np.array([iv_surface[m] for m in maturities])
-
-    # Create mesh grid
-    X, Y = np.meshgrid(moneyness_array, maturities)
-    Z = z_array * 100  # Convert to percentage
-
-    # Create 3D surface plot with custom blue colorscale
-    fig = go.Figure(data=[go.Surface(z=Z, x=X, y=Y, colorscale=custom_blue_scale)])
-
-    # Add colorbar
-    fig.update_traces(contours_z=dict(show=True, usecolormap=True,
-                                      highlightcolor="#0080FF", project_z=True))
+    # Create figure
+    fig = go.Figure(data=[
+        go.Surface(
+            z=z_array,
+            x=X,
+            y=Y,
+            colorscale=custom_blue_scale,
+            contours_z=dict(
+                show=True,
+                usecolormap=True,
+                highlightcolor="#0080FF",
+                project_z=True
+            )
+        )
+    ])
 
     # Update layout
     fig.update_layout(
@@ -378,7 +299,7 @@ def plot_3d_surface(moneyness_array: np.ndarray,
         template='plotly_dark',
         scene=dict(
             xaxis_title='Log Moneyness',
-            yaxis_title='Maturities',
+            yaxis_title='Days to Expiry',
             zaxis_title='Implied Volatility (%)'
         ),
         margin=dict(l=65, r=50, b=65, t=90)

voly/core/fit.py

@@ -19,87 +19,55 @@ warnings.filterwarnings("ignore")
 
 
 @catch_exception
-def calculate_residuals(params: List[float],
-                        ytm: float,
-                        market_data: pd.DataFrame,
+def calculate_residuals(params: List[float], ytm: float, market_data: pd.DataFrame,
                         model: Any = SVIModel) -> np.ndarray:
-    """
-    Calculate the residuals between market and model implied volatilities.
-
-    Parameters:
-    - params: Model parameters (e.g., SVI parameters [a, b, sigma, rho, m])
-    - ytm: The time to maturity in years
-    - market_data: DataFrame with market data
-    - model: Model class to use (default: SVIModel)
-
-    Returns:
-    - Array of residuals
-    """
-    # Filter market data for the specific time to maturity
+    """Calculate residuals between market and model implied volatilities."""
     maturity_data = market_data[market_data['ytm'] == ytm]
-
-    # Calculate the total implied variance (w) using the model for filtered data
     w = np.array([model.svi(x, *params) for x in maturity_data['log_moneyness']])
-
-    # Extract the actual market implied volatilities
     iv_actual = maturity_data['mark_iv'].values
-
-    # Calculate residuals between market implied volatilities and model predictions
-    residuals = iv_actual - np.sqrt(w / ytm)
-
-    return residuals
+    return iv_actual - np.sqrt(w / ytm)
 
 
 @catch_exception
-def fit_svi_parameters(market_data: pd.DataFrame,
-                       initial_params: Optional[List[float]] = None,
-                       param_bounds: Optional[Tuple] = None) -> Tuple[pd.DataFrame, Dict[str, Dict]]:
+def fit_model(market_data: pd.DataFrame,
+              model_name: str = 'svi',
+              initial_params: Optional[List[float]] = None,
+              param_bounds: Optional[Tuple] = None) -> Tuple[pd.DataFrame, pd.DataFrame]:
     """
-    Fit SVI parameters for all unique expiries in the market data.
-
-    Parameters:
-    - market_data: DataFrame with market data
-    - initial_params: Initial guess for SVI parameters (default: from SVIModel)
-    - param_bounds: Bounds for parameters (default: from SVIModel)
+    Fit a volatility model to market data.
 
     Returns:
-    - Tuple of (fit_performance DataFrame, params_dict)
+    - Tuple of (fit_results_df, fit_performance_df)
     """
+    if model_name.lower() != 'svi':
+        raise VolyError(f"Model type '{model_name}' is not supported. Currently only 'svi' is available.")
+
     # Use defaults if not provided
-    if initial_params is None:
-        initial_params = SVIModel.DEFAULT_INITIAL_PARAMS
-
-    if param_bounds is None:
-        param_bounds = SVIModel.DEFAULT_PARAM_BOUNDS
-
-    # Initialize data for fit performance
-    fit_data = {
-        'maturity_name': [],
-        'dtm': [],
-        'ytm': [],
-        'fit_success': [],
-        'cost': [],
-        'optimality': [],
-        'rmse': [],
-        'mae': [],
-        'r2': [],
-        'max_error': [],
-        'n_points': []
-    }
-
-    # Dictionary to store parameters
-    params_dict = {}
+    initial_params = initial_params or SVIModel.DEFAULT_INITIAL_PARAMS
+    param_bounds = param_bounds or SVIModel.DEFAULT_PARAM_BOUNDS
 
-    # ANSI color codes for terminal output
-    GREEN = '\033[32m'
-    RED = '\033[31m'
-    RESET = '\033[0m'
+    # Define indices for result DataFrames
+    results_index = ['s', 'u', 'maturity_date', 'dtm', 'ytm',
+                     'a', 'b', 'sigma', 'rho', 'm',
+                     'nu', 'psi', 'p', 'c', 'nu_tilde',
+                     'oi', 'volume', 'r']
+
+    performance_index = ['fit_success', 'cost', 'optimality',
+                         'rmse', 'mae', 'r2', 'max_error', 'n_points']
+
+    # Get unique maturities and sort them
+    unique_ytms = sorted(market_data['ytm'].unique())
+    maturity_names = [market_data[market_data['ytm'] == ytm]['maturity_name'].iloc[0] for ytm in unique_ytms]
+
+    # Create empty DataFrames
+    fit_results_df = pd.DataFrame(index=results_index, columns=maturity_names)
+    fit_performance_df = pd.DataFrame(index=performance_index, columns=maturity_names)
 
-    # Get unique expiries
-    unique_maturities = sorted(market_data['ytm'].unique())
+    # ANSI color codes for terminal output
+    GREEN, RED, RESET = '\033[32m', '\033[31m', '\033[0m'
 
-    for ytm in unique_maturities:
-        # Get maturity name for reporting
+    for ytm in unique_ytms:
+        # Get data for this maturity
         maturity_data = market_data[market_data['ytm'] == ytm]
         maturity_name = maturity_data['maturity_name'].iloc[0]
         dtm = maturity_data['dtm'].iloc[0]
@@ -118,16 +86,11 @@ def fit_svi_parameters(market_data: pd.DataFrame,
         except Exception as e:
             raise VolyError(f"Optimization failed for {maturity_name}: {str(e)}")
 
-        # Get parameters
-        params = result.x
-        params_dict[maturity_name] = {
-            'params': params,
-            'dtm': dtm,
-            'ytm': ytm
-        }
+        # Extract raw parameters
+        a, b, sigma, rho, m = result.x
 
         # Calculate model predictions for statistics
-        w = np.array([SVIModel.svi(x, *params) for x in maturity_data['log_moneyness']])
+        w = np.array([SVIModel.svi(x, *result.x) for x in maturity_data['log_moneyness']])
         iv_model = np.sqrt(w / ytm)
         iv_market = maturity_data['mark_iv'].values
 
@@ -136,165 +99,67 @@ def fit_svi_parameters(market_data: pd.DataFrame,
         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))
-        num_points = len(maturity_data)
-
-        # Add to fit data
-        fit_data['maturity_name'].append(maturity_name)
-        fit_data['dtm'].append(dtm)
-        fit_data['ytm'].append(ytm)
-        fit_data['fit_success'].append(result.success)
-        fit_data['cost'].append(result.cost)
-        fit_data['optimality'].append(result.optimality)
-        fit_data['rmse'].append(rmse)
-        fit_data['mae'].append(mae)
-        fit_data['r2'].append(r2)
-        fit_data['max_error'].append(max_error)
-        fit_data['n_points'].append(num_points)
-
-        if result.success:
-            logger.info(f'Optimization for {maturity_name}: {GREEN}SUCCESS{RESET}')
-        else:
-            logger.warning(f'Optimization for {maturity_name}: {RED}FAILED{RESET}')
-
-        logger.info('-------------------------------------')
-
-    # Create DataFrame with all fit performance data
-    fit_performance = pd.DataFrame(fit_data)
 
-    return fit_performance, params_dict
+        # 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
+        oi = maturity_data['open_interest'].sum() if 'open_interest' in maturity_data.columns else 0
+        volume = maturity_data['volume'].sum() if 'volume' in maturity_data.columns else 0
+        r = 0.0
 
-@catch_exception
-def create_parameters_matrix(params_dict: Dict[str, Dict]) -> Tuple[pd.DataFrame, pd.DataFrame]:
-    """
-    Create matrices of optimized parameters for each maturity.
-    Uses maturity names as column names.
-
-    Parameters:
-    - params_dict: Dictionary of raw parameter results by maturity name
-
-    Returns:
-    - Tuple of DataFrames with optimized parameters:
-      1. Raw SVI parameters (a, b, sigma, rho, m)
-      2. Jump-Wing parameters (nu, psi, p, c, nu_tilde)
-    """
-    # Get maturity names in order by dtm
-    maturity_names = sorted(params_dict.keys(),
-                            key=lambda x: params_dict[x]['dtm'])
-
-    # Create DataFrame for raw parameters
-    raw_params_matrix = pd.DataFrame(
-        columns=maturity_names,
-        index=SVIModel.PARAM_NAMES
-    )
-
-    # Create DataFrame for JW parameters
-    jw_params_matrix = pd.DataFrame(
-        columns=maturity_names,
-        index=SVIModel.JW_PARAM_NAMES
-    )
-
-    # Store YTM and DTM values for reference
-    ytm_values = {}
-    dtm_values = {}
-
-    # Fill the matrices with optimized parameters
-    for maturity_name in maturity_names:
-        result = params_dict[maturity_name]
-
-        # Extract raw SVI parameters
-        a, b, sigma, rho, m = result['params']
-        raw_params_matrix[maturity_name] = [a, b, sigma, rho, m]
-
-        # Get time to maturity
-        ytm = result['ytm']
-        ytm_values[maturity_name] = ytm
-        dtm_values[maturity_name] = result['dtm']
-
-        # Calculate JW parameters
+        # Calculate Jump-Wing parameters
         nu, psi, p, c, nu_tilde = SVIModel.raw_to_jw_params(a, b, sigma, rho, m, ytm)
-        jw_params_matrix[maturity_name] = [nu, psi, p, c, nu_tilde]
-
-    # Store YTE and DTE as attributes in all DataFrames for reference
-    attrs = {
-        'ytm_values': ytm_values,
-        'dtm_values': dtm_values
-    }
 
-    raw_params_matrix.attrs.update(attrs)
-    jw_params_matrix.attrs.update(attrs)
+        # Store results
+        result_values = [s, u, maturity_data['maturity_date'].iloc[0], dtm, ytm,
+                         a, b, rho, m, sigma, nu, psi, p, c, nu_tilde, oi, volume, r]
 
-    return raw_params_matrix, jw_params_matrix
+        for idx, val in zip(results_index, result_values):
+            fit_results_df.loc[idx, maturity_name] = val
 
+        # Store performance metrics
+        perf_values = [result.success, result.cost, result.optimality,
+                       rmse, mae, r2, max_error, len(maturity_data)]
 
-@catch_exception
-def fit_model(market_data: pd.DataFrame,
-              model_name: str = 'svi',
-              initial_params: Optional[List[float]] = None,
-              param_bounds: Optional[Tuple] = None) -> Dict[str, Any]:
-    """
-    Fit a volatility model to market data.
-
-    Parameters:
-    - market_data: DataFrame with market data
-    - model_name: Type of model to fit (default: 'svi')
-    - initial_params: Optional initial parameters for optimization (default: model's defaults)
-    - param_bounds: Optional parameter bounds for optimization (default: model's defaults)
+        for idx, val in zip(performance_index, perf_values):
+            fit_performance_df.loc[idx, maturity_name] = val
 
-    Returns:
-    - Dictionary with fitting results
-    """
-    if model_name.lower() != 'svi':
-        raise VolyError(f"Model type '{model_name}' is not supported. Currently only 'svi' is available.")
-
-    # Step 1: Fit model parameters and get performance metrics in one step
-    fit_performance, params_dict = fit_svi_parameters(
-        market_data,
-        initial_params=initial_params,
-        param_bounds=param_bounds
-    )
-
-    # Step 2: Create parameter matrices
-    raw_params_matrix, jw_params_matrix = create_parameters_matrix(params_dict)
+        # Log result
+        status = f'{GREEN}SUCCESS{RESET}' if result.success else f'{RED}FAILED{RESET}'
+        logger.info(f'Optimization for {maturity_name}: {status}')
+        logger.info('-------------------------------------')
 
-    return {
-        'raw_params_matrix': raw_params_matrix,
-        'jw_params_matrix': jw_params_matrix,
-        'fit_performance': fit_performance,
-    }
+    return fit_results_df, fit_performance_df
 
 
 @catch_exception
-def get_iv_surface(fit_results: Dict[str, Any],
+def get_iv_surface(fit_results: pd.DataFrame,
                    log_moneyness_params: Tuple[float, float, int] = (-2, 2, 500)
-                   ) -> Dict[str, Any]:
-    """
-    Generate implied volatility surface using optimized SVI parameters.
-
-    Parameters:
-    - fit_results: results from fit_model()
-    - log_moneyness_params: Tuple of (min, max, num_points) for the moneyness grid
-
-    Returns:
-    - x_domain, iv_surface
-    """
-    iv_surface = {}
-
+                   ) -> Tuple[np.ndarray, Dict[str, np.ndarray]]:
+    """Generate implied volatility surface using optimized SVI parameters."""
     # Extract moneyness parameters
     min_m, max_m, num_points = log_moneyness_params
 
-    # Generate moneyness array
-    log_moneyness_array = np.linspace(min_m, max_m, num=num_points)
-
-    # Get YTM values from the parameter matrix attributes
-    ytm_values = fit_results['fit_performance']['ytm']
-    maturity_values = fit_results['fit_performance']['maturity_name']
-    raw_params_matrix = fit_results['raw_params_matrix']
+    # Generate moneyness array and initialize surface dictionary
+    moneyness_array = np.linspace(min_m, max_m, num=num_points)
+    iv_surface = {}
 
     # Generate implied volatility for each maturity
-    for maturity, ytm in zip(maturity_values, ytm_values):
-        svi_params = raw_params_matrix[maturity].values
-        w_svi = [SVIModel.svi(x, *svi_params) for x in log_moneyness_array]
-        iv_surface[maturity] = np.sqrt(np.array(w_svi) / ytm)
+    for maturity in fit_results.columns:
+        # Extract parameters and YTM
+        params = [
+            fit_results.loc['a', maturity],
+            fit_results.loc['b', maturity],
+            fit_results.loc['sigma', maturity],
+            fit_results.loc['rho', maturity],
+            fit_results.loc['m', maturity]
+        ]
+        ytm = fit_results.loc['ytm', maturity]
+
+        # Calculate SVI total implied variance and convert to IV
+        w_svi = np.array([SVIModel.svi(x, *params) for x in moneyness_array])
+        iv_surface[maturity] = np.sqrt(w_svi / ytm)
 
     return moneyness_array, iv_surface

{voly-0.0.57.dist-info → voly-0.0.59.dist-info}/METADATA

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

{voly-0.0.57.dist-info → voly-0.0.59.dist-info}/RECORD

@@ -4,15 +4,15 @@ voly/exceptions.py,sha256=PBsbn1vNMvKcCJwwJ4lBO6glD85jo1h2qiEmD7ArAjs,92
 voly/formulas.py,sha256=Xgaq4lx1fNzRfu9W84fMNeH6GRJ0FNFNUUUYn5ffjjE,8843
 voly/models.py,sha256=LXXIlpXZQEfXTuCngxC8Hd3bWtw6wdXDCSGxTLmHM-c,3659
 voly/core/__init__.py,sha256=bu6fS2I1Pj9fPPnl-zY3L7NqrZSY5Zy6NY2uMUvdhKs,183
-voly/core/charts.py,sha256=T8cogkiHj8NcFxfARumNvAjLJUAxsMlHUOVgshwjye8,26474
+voly/core/charts.py,sha256=kWjd3sfvTalfuElt7vSuRPtYuWpMoJ9-L2Z9Mj-mOMQ,24374
 voly/core/data.py,sha256=e8qBArubNqPkrfuIYB_q2WhRf7TKzA4Z3FhMC-xyLEE,8862
-voly/core/fit.py,sha256=aCF8ZWmGKCJN720hqz6JbfYq1NNFzEOfi3IP-fUCXX4,9894
+voly/core/fit.py,sha256=YClTiODlH9CBAqv5VNBlE0k6qD22Hwic91PnTWstyj4,6490
 voly/core/interpolate.py,sha256=ztVIePJZOh-CIbn69wkh1JW2rKywNe2FEewRN0zcSAo,8185
 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.57.dist-info/LICENSE,sha256=wcHIVbE12jfcBOai_wqBKY6xvNQU5E909xL1zZNq_2Q,1065
-voly-0.0.57.dist-info/METADATA,sha256=G-_VF5HjhYn9Wu8cWP_YVMwZ_IyldPq6CygB0DqPGsA,4092
-voly-0.0.57.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
-voly-0.0.57.dist-info/top_level.txt,sha256=ZfLw2sSxF-LrKAkgGjOmeTcw6_gD-30zvtdEY5W4B7c,5
-voly-0.0.57.dist-info/RECORD,,
+voly-0.0.59.dist-info/LICENSE,sha256=wcHIVbE12jfcBOai_wqBKY6xvNQU5E909xL1zZNq_2Q,1065
+voly-0.0.59.dist-info/METADATA,sha256=z6kwXaTKNBU4imtpUyRVsWGcNdZyajgwMjXxfUe2DmY,4092
+voly-0.0.59.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
+voly-0.0.59.dist-info/top_level.txt,sha256=ZfLw2sSxF-LrKAkgGjOmeTcw6_gD-30zvtdEY5W4B7c,5
+voly-0.0.59.dist-info/RECORD,,