voly 0.0.70__tar.gz → 0.0.72__tar.gz

{voly-0.0.70/src/voly.egg-info → voly-0.0.72}/PKG-INFO

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

{voly-0.0.70 → voly-0.0.72}/pyproject.toml

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

{voly-0.0.70 → voly-0.0.72}/src/voly/client.py

@@ -22,7 +22,7 @@ from voly.core.fit import fit_model, get_iv_surface
 from voly.core.rnd import get_rnd_surface, calculate_pdf, calculate_cdf, calculate_strike_probability
 from voly.core.interpolate import interpolate_model
 from voly.core.charts import (
-    plot_all_smiles, plot_3d_surface, plot_parameters, plot_fit_performance,
+    plot_all_smiles, plot_raw_parameters, plot_jw_parameters, plot_fit_performance, plot_3d_surface,
     plot_fit_performance, plot_rnd, plot_pdf, plot_cdf, plot_rnd_all_expiries,
     plot_rnd_3d, plot_rnd_statistics, plot_interpolated_surface
 )
@@ -404,7 +404,7 @@ class VolyClient:
         )
 
         # Plot parameters
-        plots['raw_params'] = plot_parameters(fit_results)
+        plots['raw_params'] = plot_raw_parameters(fit_results)
         plots['jw_params'] = plot_jw_parameters(fit_results)
 
         # Plot fit statistics

{voly-0.0.70 → voly-0.0.72}/src/voly/core/charts.py

@@ -141,7 +141,7 @@ def plot_all_smiles(x_surface: Dict[str, np.ndarray],
 
 
 @catch_exception
-def plot_parameters(fit_results: pd.DataFrame) -> go.Figure:
+def plot_raw_parameters(fit_results: pd.DataFrame) -> go.Figure:
     """
     Plot raw SVI parameters across different expiries.
 
@@ -165,7 +165,7 @@ def plot_parameters(fit_results: pd.DataFrame) -> go.Figure:
     maturity_names = fit_results.index
 
     # Create hover text with maturity info
-    tick_labels = [f"{m} (DTE: {fit_results.loc[m, 'dtm']:.1f}, YTE: {fit_results.loc[m, 'ytm']:.4f})"
+    tick_labels = [f"{m} (DTE: {fit_results.loc[m, 'dtm']:.1f}"
                    for m in maturity_names]
 
     # Plot each parameter
@@ -450,17 +450,16 @@ def plot_3d_surface(x_surface: Dict[str, np.ndarray],
 
 
 @catch_exception
-def plot_rnd(x_domain: np.ndarray,
+def plot_rnd(moneyness_array: np.ndarray,
              rnd_values: np.ndarray,
-             spot_price: float = 1.0,
-             title: str = 'Risk-Neutral Density') -> go.Figure:
+             spot_price: float = 1.0) -> go.Figure:
     """
     Plot risk-neutral density (RND).
 
     Parameters:
-    - x_domain: Grid of domain values
+    - moneyness_array: Grid of log-moneyness values
     - rnd_values: RND values
-    - spot_price: Spot price for reference
+    - spot_price: Spot price for converting to absolute prices
     - title: Plot title
 
     Returns:
@@ -469,12 +468,11 @@ def plot_rnd(x_domain: np.ndarray,
     # Create figure
     fig = go.Figure()
 
-    # Convert x_domain to prices (assuming it's in log_moneyness)
-    # This may need adjustment if the domain is not log_moneyness
-    prices = spot_price * np.exp(x_domain)
+    # Convert to prices and normalize RND
+    prices = spot_price * np.exp(moneyness_array)
 
     # Normalize the RND to integrate to 1
-    dx = x_domain[1] - x_domain[0]
+    dx = moneyness_array[1] - moneyness_array[0]
     total_density = np.sum(rnd_values) * dx
     normalized_rnd = rnd_values / total_density if total_density > 0 else rnd_values
 
@@ -510,7 +508,7 @@ def plot_rnd(x_domain: np.ndarray,
 
     # Update layout
     fig.update_layout(
-        title=title,
+        title='Risk-Neutral Density',
         xaxis_title='Price',
         yaxis_title='Density',
         template='plotly_dark',
@@ -518,3 +516,443 @@ def plot_rnd(x_domain: np.ndarray,
     )
 
     return fig
+
+
+@catch_exception
+def plot_rnd_all_expiries(moneyness_array: np.ndarray,
+                          rnd_surface: Dict[str, np.ndarray],
+                          fit_results: Dict[str, Any],
+                          spot_price: float = 1.0) -> go.Figure:
+    """
+    Plot risk-neutral densities for all expiries.
+
+    Parameters:
+    - moneyness_array: Grid of log-moneyness values
+    - rnd_surface: Dictionary mapping maturity names to RND arrays
+    - param_matrix: Matrix containing model parameters with maturity info
+    - spot_price: Spot price for converting to absolute prices
+
+    Returns:
+    - Plotly figure
+    """
+    # Get maturity information
+    dte_values = fit_results['fit_performance']['DTE']
+
+    # Create figure
+    fig = go.Figure()
+
+    # Get maturity names in order by DTE
+    maturity_names = sorted(rnd_surface.keys(), key=lambda x: dte_values[x])
+
+    # Create color scale from purple to green
+    n_maturities = len(maturity_names)
+    colors = [f'rgb({int(255 - i * 255 / n_maturities)}, {int(i * 255 / n_maturities)}, 255)'
+              for i in range(n_maturities)]
+
+    # Convert to prices
+    prices = spot_price * np.exp(moneyness_array)
+
+    # Add traces for each expiry
+    for i, maturity_name in enumerate(maturity_names):
+        rnd = rnd_surface[maturity_name]
+        dte = dte_values[maturity_name]
+
+        # Normalize the RND
+        dx = moneyness_array[1] - moneyness_array[0]
+        total_density = np.sum(rnd) * dx
+        normalized_rnd = rnd / total_density if total_density > 0 else rnd
+
+        # Add trace
+        fig.add_trace(
+            go.Scatter(
+                x=prices,
+                y=normalized_rnd,
+                mode='lines',
+                name=f"{maturity_name} (DTE: {dte:.1f})",
+                line=dict(color=colors[i], width=2),
+            )
+        )
+
+    # Add vertical line at spot price
+    fig.add_shape(
+        type='line',
+        x0=spot_price, y0=0,
+        x1=spot_price, y1=1,  # Will be scaled automatically
+        line=dict(color='red', width=2, dash='dash')
+    )
+
+    # Update layout
+    fig.update_layout(
+        title="Risk-Neutral Densities Across Expiries",
+        xaxis_title='Price',
+        yaxis_title='Density',
+        template='plotly_dark',
+        legend=dict(
+            yanchor="top",
+            y=0.99,
+            xanchor="left",
+            x=0.01
+        )
+    )
+
+    return fig
+
+
+@catch_exception
+def plot_rnd_3d(moneyness_array: np.ndarray,
+                rnd_surface: Dict[str, np.ndarray],
+                param_matrix: pd.DataFrame,
+                spot_price: float = 1.0) -> go.Figure:
+    """
+    Plot 3D surface of risk-neutral densities.
+
+    Parameters:
+    - moneyness_array: Grid of log-moneyness values
+    - rnd_surface: Dictionary mapping maturity names to RND arrays
+    - param_matrix: Matrix containing model parameters with maturity info
+    - spot_price: Spot price for converting to absolute prices
+
+    Returns:
+    - Plotly figure
+    """
+    # Get maturity information
+    dte_values = param_matrix.attrs['dte_values']
+
+    # Get maturity names in order by DTE
+    maturity_names = sorted(rnd_surface.keys(), key=lambda x: dte_values[x])
+
+    # Extract DTE values for z-axis
+    dte_list = [dte_values[name] for name in maturity_names]
+
+    # Convert to prices
+    prices = spot_price * np.exp(moneyness_array)
+
+    # Create z-data matrix and normalize RNDs
+    z_data = np.zeros((len(maturity_names), len(prices)))
+
+    for i, name in enumerate(maturity_names):
+        rnd = rnd_surface[name]
+
+        # Normalize the RND
+        dx = moneyness_array[1] - moneyness_array[0]
+        total_density = np.sum(rnd) * dx
+        normalized_rnd = rnd / total_density if total_density > 0 else rnd
+
+        z_data[i] = normalized_rnd
+
+    # Create mesh grid
+    X, Y = np.meshgrid(prices, dte_list)
+
+    # Create 3D surface
+    fig = go.Figure(data=[
+        go.Surface(
+            z=z_data,
+            x=X,
+            y=Y,
+            colorscale='Viridis',
+            showscale=True
+        )
+    ])
+
+    # Update layout
+    fig.update_layout(
+        title="3D Risk-Neutral Density Surface",
+        scene=dict(
+            xaxis_title="Price",
+            yaxis_title="Days to Expiry",
+            zaxis_title="Density"
+        ),
+        margin=dict(l=65, r=50, b=65, t=90),
+        template="plotly_dark"
+    )
+
+    return fig
+
+
+@catch_exception
+def plot_rnd_statistics(rnd_statistics: pd.DataFrame,
+                        rnd_probabilities: pd.DataFrame) -> Tuple[go.Figure, go.Figure]:
+    """
+    Plot RND statistics and probabilities.
+
+    Parameters:
+    - rnd_statistics: DataFrame with RND statistics
+    - rnd_probabilities: DataFrame with RND probabilities
+
+    Returns:
+    - Tuple of (statistics_fig, probabilities_fig)
+    """
+    # Create subplot figure for key statistics
+    stats_fig = make_subplots(
+        rows=1, cols=3,
+        subplot_titles=("Standard Deviation (%) vs. DTE",
+                        "Skewness vs. DTE",
+                        "Excess Kurtosis vs. DTE")
+    )
+
+    # Add traces for each statistic
+    stats_fig.add_trace(
+        go.Scatter(
+            x=rnd_statistics["dte"],
+            y=rnd_statistics["std_dev_pct"],
+            mode="lines+markers",
+            name="Standard Deviation (%)",
+            hovertemplate="DTE: %{x:.1f}<br>Std Dev: %{y:.2f}%"
+        ),
+        row=1, col=1
+    )
+
+    stats_fig.add_trace(
+        go.Scatter(
+            x=rnd_statistics["dte"],
+            y=rnd_statistics["skewness"],
+            mode="lines+markers",
+            name="Skewness",
+            hovertemplate="DTE: %{x:.1f}<br>Skewness: %{y:.4f}"
+        ),
+        row=1, col=2
+    )
+
+    stats_fig.add_trace(
+        go.Scatter(
+            x=rnd_statistics["dte"],
+            y=rnd_statistics["excess_kurtosis"],
+            mode="lines+markers",
+            name="Excess Kurtosis",
+            hovertemplate="DTE: %{x:.1f}<br>Excess Kurtosis: %{y:.4f}"
+        ),
+        row=1, col=3
+    )
+
+    # Update layout
+    stats_fig.update_layout(
+        title="Risk-Neutral Density Statistics Across Expiries",
+        template="plotly_dark",
+        height=500,
+        showlegend=False
+    )
+
+    # Update axes
+    stats_fig.update_xaxes(title_text="Days to Expiry", row=1, col=1)
+    stats_fig.update_xaxes(title_text="Days to Expiry", row=1, col=2)
+    stats_fig.update_xaxes(title_text="Days to Expiry", row=1, col=3)
+
+    stats_fig.update_yaxes(title_text="Standard Deviation (%)", row=1, col=1)
+    stats_fig.update_yaxes(title_text="Skewness", row=1, col=2)
+    stats_fig.update_yaxes(title_text="Excess Kurtosis", row=1, col=3)
+
+    # Create a second figure for probability thresholds
+    prob_fig = go.Figure()
+
+    # Get probability columns (those starting with "p_")
+    prob_cols = [col for col in rnd_probabilities.columns if col.startswith("p_")]
+
+    # Sort the columns to ensure they're in order by threshold value
+    prob_cols_above = sorted([col for col in prob_cols if "above" in col],
+                             key=lambda x: float(x.split("_")[2]))
+    prob_cols_below = sorted([col for col in prob_cols if "below" in col],
+                             key=lambda x: float(x.split("_")[2]))
+
+    # Color gradients
+    green_colors = [
+        'rgba(144, 238, 144, 1)',  # Light green
+        'rgba(50, 205, 50, 1)',  # Lime green
+        'rgba(34, 139, 34, 1)',  # Forest green
+        'rgba(0, 100, 0, 1)'  # Dark green
+    ]
+
+    red_colors = [
+        'rgba(139, 0, 0, 1)',  # Dark red
+        'rgba(220, 20, 60, 1)',  # Crimson
+        'rgba(240, 128, 128, 1)',  # Light coral
+        'rgba(255, 182, 193, 1)'  # Light pink/red
+    ]
+
+    # Add lines for upside probabilities (green)
+    for i, col in enumerate(prob_cols_above):
+        threshold = float(col.split("_")[2])
+        label = f"P(X > {threshold})"
+
+        # Select color based on how far OTM
+        color_idx = min(i, len(green_colors) - 1)
+
+        prob_fig.add_trace(
+            go.Scatter(
+                x=rnd_probabilities["dte"],
+                y=rnd_probabilities[col] * 100,  # Convert to percentage
+                mode="lines+markers",
+                name=label,
+                line=dict(color=green_colors[color_idx], width=3),
+                marker=dict(size=8, color=green_colors[color_idx]),
+                hovertemplate="DTE: %{x:.1f}<br>" + label + ": %{y:.2f}%"
+            )
+        )
+
+    # Add lines for downside probabilities (red)
+    for i, col in enumerate(prob_cols_below):
+        threshold = float(col.split("_")[2])
+        label = f"P(X < {threshold})"
+
+        # Select color based on how far OTM
+        color_idx = min(i, len(red_colors) - 1)
+
+        prob_fig.add_trace(
+            go.Scatter(
+                x=rnd_probabilities["dte"],
+                y=rnd_probabilities[col] * 100,  # Convert to percentage
+                mode="lines+markers",
+                name=label,
+                line=dict(color=red_colors[color_idx], width=3),
+                marker=dict(size=8, color=red_colors[color_idx]),
+                hovertemplate="DTE: %{x:.1f}<br>" + label + ": %{y:.2f}%"
+            )
+        )
+
+    # Update layout
+    prob_fig.update_layout(
+        title="Probability Thresholds Across Expiries",
+        xaxis_title="Days to Expiry",
+        yaxis_title="Probability (%)",
+        template="plotly_dark",
+        legend=dict(
+            yanchor="top",
+            y=0.99,
+            xanchor="right",
+            x=0.99
+        )
+    )
+
+    return stats_fig, prob_fig
+
+
+@catch_exception
+def plot_cdf(moneyness_array: np.ndarray,
+             rnd_values: np.ndarray,
+             spot_price: float = 1.0,
+             title: str = 'Cumulative Distribution Function') -> go.Figure:
+    """
+    Plot the cumulative distribution function (CDF) from RND values.
+
+    Parameters:
+    - moneyness_array: Grid of log-moneyness values
+    - rnd_values: RND values
+    - spot_price: Spot price for converting to absolute prices
+    - title: Plot title
+
+    Returns:
+    - Plotly figure
+    """
+    # Convert to prices and normalize RND
+    prices = spot_price * np.exp(moneyness_array)
+
+    # Normalize the RND
+    dx = moneyness_array[1] - moneyness_array[0]
+    total_density = np.sum(rnd_values) * dx
+    normalized_rnd = rnd_values / total_density if total_density > 0 else rnd_values
+
+    # Calculate CDF
+    cdf = np.cumsum(normalized_rnd) * dx
+
+    # Create figure
+    fig = go.Figure()
+
+    # Add CDF trace
+    fig.add_trace(
+        go.Scatter(
+            x=prices,
+            y=cdf,
+            mode='lines',
+            name='CDF',
+            line=dict(color='#00FFC1', width=2)
+        )
+    )
+
+    # Add vertical line at spot price
+    fig.add_shape(
+        type='line',
+        x0=spot_price, y0=0,
+        x1=spot_price, y1=1,
+        line=dict(color='red', width=2, dash='dash')
+    )
+
+    # Add horizontal line at CDF=0.5 (median)
+    fig.add_shape(
+        type='line',
+        x0=prices[0], y0=0.5,
+        x1=prices[-1], y1=0.5,
+        line=dict(color='orange', width=2, dash='dash')
+    )
+
+    # Add annotation for spot price
+    fig.add_annotation(
+        x=spot_price,
+        y=1.05,
+        text=f"Spot: {spot_price}",
+        showarrow=False,
+        font=dict(color='red')
+    )
+
+    # Update layout
+    fig.update_layout(
+        title=title,
+        xaxis_title='Price',
+        yaxis_title='Cumulative Probability',
+        template='plotly_dark',
+        yaxis=dict(range=[0, 1.1]),
+        showlegend=False
+    )
+
+    return fig
+
+
+@catch_exception
+def plot_pdf(moneyness_array: np.ndarray,
+             rnd_values: np.ndarray,
+             spot_price: float = 1.0,
+             title: str = 'Probability Density Function') -> go.Figure:
+    """
+    Plot the probability density function (PDF) from RND values.
+
+    Parameters:
+    - moneyness_array: Grid of log-moneyness values
+    - rnd_values: RND values
+    - spot_price: Spot price for converting to absolute prices
+    - title: Plot title
+
+    Returns:
+    - Plotly figure
+    """
+    # This is essentially the same as plot_rnd but with a different title
+    return plot_rnd(moneyness_array, rnd_values, spot_price, title)
+
+
+@catch_exception
+def plot_interpolated_surface(
+        interp_results: Dict[str, Any],
+        title: str = 'Interpolated Implied Volatility Surface'
+) -> go.Figure:
+    """
+    Plot interpolated implied volatility surface.
+
+    Parameters:
+    - interp_results: Dictionary with interpolation results
+    - title: Plot title
+
+    Returns:
+    - Plotly figure
+    """
+    # Extract data from interpolation results
+    moneyness_array = interp_results['moneyness_array']
+    target_expiries_years = interp_results['target_expiries_years']
+    iv_surface = interp_results['iv_surface']
+
+    # Create a 3D surface plot
+    fig = plot_3d_surface(
+        moneyness=moneyness_array,
+        expiries=target_expiries_years,
+        iv_surface=iv_surface,
+        title=title
+    )
+
+    return fig
+

{voly-0.0.70 → voly-0.0.72/src/voly.egg-info}/PKG-INFO

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