voly 0.0.29__tar.gz → 0.0.32__tar.gz

{voly-0.0.29/src/voly.egg-info → voly-0.0.32}/PKG-INFO

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

{voly-0.0.29 → voly-0.0.32}/pyproject.toml

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

{voly-0.0.29 → voly-0.0.32}/src/voly/client.py

@@ -18,8 +18,8 @@ from voly.formulas import (
     bs, delta, gamma, vega, theta, rho, vanna, volga, charm, greeks, iv
 )
 from voly.core.data import fetch_option_chain, process_option_chain
-from voly.core.fit import fit_model, get_surface
-from voly.core.rnd import calculate_rnd, calculate_pdf, calculate_cdf, calculate_strike_probability
+from voly.core.fit import fit_model, get_iv_surface
+from voly.core.rnd import get_rnd, 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,
@@ -322,9 +322,9 @@ class VolyClient:
         return fit_results
 
     @staticmethod
-    def get_surface(fit_results: Dict[str, Any],
-                    moneyness_params: Tuple[float, float, int] = (-2, 2, 500)
-                    ) -> Dict[str, Any]:
+    def get_iv_surface(fit_results: Dict[str, Any],
+                       moneyness_params: Tuple[float, float, int] = (-2, 2, 500)
+                       ) -> Dict[str, Any]:
         """
         Generate implied volatility surface using optimized SVI parameters.
 
@@ -333,18 +333,15 @@ class VolyClient:
         - moneyness_params: Tuple of (min, max, num_points) for the moneyness grid
 
         Returns:
-        - Tuple of (moneyness_grid, iv_surface)
+        - Tuple of (moneyness_array, iv_surface)
         """
         # Generate the surface
-        moneyness_grid, iv_surface = get_surface(
+        iv_surface = get_iv_surface(
             fit_results=fit_results,
             moneyness_params=moneyness_params
         )
 
-        return {
-            'moneyness_grid': moneyness_grid,
-            'iv_surface': iv_surface
-        }
+        return iv_surface
 
     @staticmethod
     def plot_model(fit_results: Dict[str, Any],
@@ -364,7 +361,7 @@ class VolyClient:
         """
         plots = {}
 
-        moneyness_grid, iv_surface = get_surface(fit_results, moneyness_params)
+        moneyness_array, iv_surface = get_iv_surface(fit_results, moneyness_params)
 
         # Extract data from fit results
         raw_param_matrix = fit_results['raw_param_matrix']
@@ -372,10 +369,10 @@ class VolyClient:
         fit_performance = fit_results['fit_performance']
 
         # Plot volatility smiles
-        plots['smiles'] = plot_all_smiles(moneyness_grid, iv_surface, market_data)
+        plots['smiles'] = plot_all_smiles(moneyness_array, iv_surface, market_data)
 
         # Plot 3D surface
-        plots['surface_3d'] = plot_3d_surface(moneyness_grid, iv_surface)
+        plots['surface_3d'] = plot_3d_surface(moneyness_array, iv_surface)
 
         # Plot parameters
         plots['raw_params'], plots['jw_params'] = plot_parameters(raw_param_matrix, jw_param_matrix)
@@ -390,34 +387,55 @@ class VolyClient:
     # -------------------------------------------------------------------------
 
     @staticmethod
-    def rnd(fit_results: Dict[str, Any],
-            maturity: Optional[str] = None,
-            spot_price: float = 1.0,
-            plot: bool = False) -> Dict[str, Any]:
+    def get_rnd(svi_params_list: float[List],
+                moneyness_params: Tuple[float, float, int] = (-2, 2, 500)
+                ) -> np.ndarray:
         """
         Calculate risk-neutral density from fitted model.
 
         Parameters:
-        - fit_results: Dictionary with fitting results from fit_model()
-        - maturity: Optional maturity name to calculate RND for a specific expiry
-        - spot_price: Current spot price
-        - plot: Whether to generate and return plots
 
         Returns:
-        - Dictionary with RND results and optional plots
+        - Array with RND results over moneyness
         """
         logger.info("Calculating risk-neutral density")
 
-        # Calculate RND
-        rnd_results = calculate_rnd(fit_results, maturity, spot_price)
+        # Generate the surface
+        moneyness_array, iv_surface = get_rnd(
+            svi_params_list=svi_params_list,
+            moneyness_params=moneyness_params
+        )
 
-        # Generate plots if requested
-        if plot:
-            logger.info("Generating RND plots")
-            plots = generate_all_plots(fit_results, rnd_results)
-            rnd_results['plots'] = plots
+        return {
+            'moneyness_grid': moneyness_array,
+            'rnd_values': rnd_values
+        }
+
+    @staticmethod
+    def get_rnd_surface(fit_results: Dict[str, Any],
+                        moneyness_params: Tuple[float, float, int] = (-2, 2, 500)
+                        ) -> Dict[str, np.ndarray]:
+        """
+        Calculate risk-neutral density from fitted model.
+
+        Parameters:
+
+        Returns:
+        - Array with RND results over moneyness
+        """
+        logger.info("Calculating risk-neutral density")
+
+        # Generate the surface
+        moneyness_array, iv_surface = get_rnd_surface(
+            fit_results=fit_results,
+            moneyness_params=moneyness_params
+        )
+
+        return {
+            'moneyness_grid': moneyness_grid,
+            'rnd_values': rnd_values
+        }
 
-        return rnd_results
 
     @staticmethod
     def pdf(rnd_results: Dict[str, Any],

{voly-0.0.29 → voly-0.0.32}/src/voly/core/charts.py

@@ -358,8 +358,8 @@ def plot_3d_surface(moneyness_grid: np.ndarray,
     Returns:
     - Plotly figure
     """
-    start_color = '#0080FF'
-    end_color = '#004080'  # Darker blue
+    start_color = '#60AEFC'
+    end_color = '#002040'  # Darker blue
     custom_blue_scale = [[0, start_color], [1, end_color]]
     yte_values = list(iv_surface.keys())
 

{voly-0.0.29 → voly-0.0.32}/src/voly/core/fit.py

@@ -265,18 +265,18 @@ def fit_model(market_data: pd.DataFrame,
 
 
 @catch_exception
-def get_surface(fit_results: Dict[str, Any],
-                moneyness_params: Tuple[float, float, int] = (-2, 2, 500)
-                ) -> Dict[str, Any]:
+def get_iv_surface(fit_results: Dict[str, Any],
+                   moneyness_params: Tuple[float, float, int] = (-2, 2, 500)
+                   ) -> Dict[str, Any]:
     """
     Generate implied volatility surface using optimized SVI parameters.
 
     Parameters:
-    - param_matrix: Matrix of optimized SVI parameters from fit_results
+    - fit_results: results from fit_model()
     - moneyness_params: Tuple of (min, max, num_points) for the moneyness grid
 
     Returns:
-    - Tuple of (moneyness_grid, iv_surface)
+    - iv_surface
     """
     iv_surface = {}
 
@@ -284,7 +284,7 @@ def get_surface(fit_results: Dict[str, Any],
     min_m, max_m, num_points = moneyness_params
 
     # Generate moneyness grid
-    moneyness_grid = np.linspace(min_m, max_m, num=num_points)
+    moneyness_array = np.linspace(min_m, max_m, num=num_points)
 
     # Get YTE values from the parameter matrix attributes
     yte_values = fit_results['fit_performance']['YTE']
@@ -294,7 +294,7 @@ def get_surface(fit_results: Dict[str, Any],
     # Generate implied volatility for each expiry
     for maturity, yte in zip(maturity_values, yte_values):
         svi_params = param_matrix[maturity].values
-        w_svi = [SVIModel.svi(x, *svi_params) for x in moneyness_grid]
+        w_svi = [SVIModel.svi(x, *svi_params) for x in moneyness_array]
         iv_surface[yte] = np.sqrt(np.array(w_svi) / yte)
 
-    return moneyness_grid, iv_surface
+    return iv_surface

{voly-0.0.29 → voly-0.0.32}/src/voly/core/rnd.py

@@ -9,71 +9,75 @@ from typing import Dict, List, Tuple, Optional, Union, Any
 from voly.utils.logger import logger, catch_exception
 from voly.exceptions import VolyError
 from voly.models import SVIModel
-from voly.formulas import rnd
 
 
 @catch_exception
-def calculate_risk_neutral_density(
-        log_moneyness: np.ndarray,
-        params: List[float],
-        model: Any = SVIModel
-) -> np.ndarray:
-    """
-    Calculate the risk-neutral density (RND) from model parameters.
+def rnd(moneyness_array: float, total_var: float) -> float:
+    return np.exp(-(moneyness_array ** 2) / (2 * total_var)) / (np.sqrt(2 * np.pi * total_var))
 
-    Parameters:
-    - log_moneyness: Array of log-moneyness values
-    - params: Model parameters (e.g., SVI parameters [a, b, sigma, rho, m])
-    - model: Model class to use (default: SVIModel)
 
-    Returns:
-    - Array of RND values corresponding to each log-moneyness value
-    """
+@catch_exception
+def get_rnd(svi_params_list: float[List],
+            moneyness_params: Tuple[float, float, int] = (-2, 2, 500)
+            ) -> np.ndarray:
+
     # Adjust parameter order to match function signatures
-    a, b, sigma, rho, m = params
+    a, b, sigma, rho, m = svi_params_list
+
+    # Extract moneyness parameters
+    min_m, max_m, num_points = moneyness_params
+
+    # Generate moneyness grid
+    moneyness_array = np.linspace(min_m, max_m, num=num_points)
 
     # Calculate total variance
-    total_var = np.array([model.svi(x, a, b, sigma, rho, m) for x in log_moneyness])
+    total_var = np.array([SVIModel.svi(x, a, b, sigma, rho, m) for x in moneyness_array])
 
     # Calculate risk-neutral density using the base RND function
-    rnd_values = np.array([rnd(x, var) for x, var in zip(log_moneyness, total_var)])
+    rnd_values = np.array([rnd(x, var) for x, var in zip(moneyness_array, total_var)])
 
-    return rnd_values
+    return moneyness_array, rnd_values
 
 
 @catch_exception
-def calculate_rnd_for_all_expiries(
-        moneyness_grid: np.ndarray,
-        param_matrix: pd.DataFrame,
-        model: Any = SVIModel
-) -> Dict[str, np.ndarray]:
+def get_rnd_surface(fit_results: Dict[str, Any],
+                    moneyness_params: Tuple[float, float, int] = (-2, 2, 500)
+                    ) -> Dict[str, np.ndarray]:
     """
-    Calculate RND for all expiries in the parameter matrix.
+    Calculate RND for all expiries using the SVI parameter matrix.
 
     Parameters:
-    - moneyness_grid: Grid of log-moneyness values
-    - param_matrix: Matrix containing model parameters for each expiry
-    - model: Model class to use (default: SVIModel)
+    - moneyness_params: Tuple of (min, max, num_points) for the moneyness grid
+    - fit_results: results from fit_model()
 
     Returns:
     - Dictionary mapping maturity names to RND arrays
     """
     rnd_surface = {}
 
-    # Get YTE values from the parameter matrix attributes
-    yte_values = param_matrix.attrs['yte_values']
+    # Extract moneyness parameters
+    min_m, max_m, num_points = moneyness_params
+
+    # Generate moneyness grid
+    moneyness_array = np.linspace(min_m, max_m, num=num_points)
+
+    # Get YTE values from the fit results attributes
+    yte_values = fit_results['fit_performance']['YTE']
+    maturity_values = fit_results['fit_performance']['Maturity']
+    param_matrix = fit_results['raw_param_matrix']
+
+    # Generate implied volatility for each expiry
+    for maturity, yte in zip(maturity_values, yte_values):
+        svi_params_list = list(param_matrix[maturity].values)
+
+        # Adjust parameter order to match function signatures
+        a, b, sigma, rho, m = svi_params_list
+
+        # Calculate total variance
+        total_var = np.array([SVIModel.svi(x, a, b, sigma, rho, m) for x in moneyness_array])
 
-    # Calculate RND for each expiry
-    for maturity_name, yte in yte_values.items():
-        params = param_matrix[maturity_name].values
-
-        # Calculate RND
-        rnd_values = calculate_risk_neutral_density(
-            moneyness_grid,
-            params,
-            yte,
-            model=model
-        )
+        # Calculate risk-neutral density using the base RND function
+        rnd_values = np.array([rnd(x, var) for x, var in zip(moneyness_array, total_var)])
 
         rnd_surface[maturity_name] = rnd_values
 

{voly-0.0.29 → voly-0.0.32}/src/voly/formulas.py

@@ -236,8 +236,3 @@ def iv(option_price: float, s: float, k: float, r: float, t: float,
 
     # If we reach here, we didn't converge
     return np.nan
-
-
-@catch_exception
-def rnd(log_moneyness: float, total_var: float) -> float:
-    return np.exp(-(log_moneyness ** 2) / (2 * total_var)) / (np.sqrt(2 * np.pi * total_var))

{voly-0.0.29 → voly-0.0.32/src/voly.egg-info}/PKG-INFO

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