voly 0.0.61__py3-none-any.whl → 0.0.63__py3-none-any.whl

voly/client.py

@@ -339,7 +339,7 @@ class VolyClient:
 
         # Fit the model
         fit_results, fit_performance = fit_model(
-            market_data=market_data,
+            option_chain=option_chain,
             model_name=model_name,
             initial_params=initial_params,
             param_bounds=param_bounds
@@ -352,32 +352,34 @@ class VolyClient:
 
     @staticmethod
     def get_iv_surface(fit_results: Dict[str, Any],
-                       moneyness_params: Tuple[float, float, int] = (-2, 2, 500)
+                       log_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
-        - moneyness_params: Tuple of (min, max, num_points) for the moneyness grid
+            - fit_results: DataFrame from fit_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')
 
         Returns:
-        - Tuple of (moneyness_array, iv_surface)
+        - Tuple of (iv_surface, x_surface)
         """
         # Generate the surface
-        moneyness_array, iv_surface = get_iv_surface(
+        iv_surface, x_surface = get_iv_surface(
             fit_results=fit_results,
-            moneyness_params=moneyness_params
+            log_moneyness_params=log_moneyness_params,
+            return_domain=return_domain
         )
 
         return {
-            'moneyness_array': moneyness_array,
-            'iv_surface': iv_surface
+            'iv_surface': iv_surface,
+            'x_surface': x_surface
         }
 
     @staticmethod
     def plot_model(fit_results: Dict[str, Any],
-                   market_data: pd.DataFrame = None,
+                   option_chain: pd.DataFrame = None,
                    moneyness_params: Tuple[float, float, int] = (-2, 2, 500)
                    ) -> Dict[str, go.Figure]:
         """
@@ -385,7 +387,7 @@ class VolyClient:
 
         Parameters:
         - fit_results: Dictionary with fitting results from fit_model()
-        - market_data: Optional market data for comparison
+        - option_chain: Optional market data for comparison
         - moneyness_params: Grid of log-moneyness values
 
         Returns:
@@ -401,7 +403,7 @@ class VolyClient:
         fit_performance = fit_results['fit_performance']
 
         # Plot volatility smiles
-        plots['smiles'] = plot_all_smiles(moneyness_array, iv_surface, market_data)
+        plots['smiles'] = plot_all_smiles(moneyness_array, iv_surface, option_chain)
 
         # Plot 3D surface
         plots['surface_3d'] = plot_3d_surface(moneyness_array, iv_surface)

voly/core/charts.py

@@ -21,7 +21,7 @@ pio.renderers.default = "browser"
 @catch_exception
 def plot_volatility_smile(moneyness_array: np.ndarray,
                           iv_array: np.ndarray,
-                          market_data: pd.DataFrame = None,
+                          option_chain: pd.DataFrame = None,
                           maturity: Optional[str] = None) -> go.Figure:
     """Plot volatility smile for a single expiry."""
     fig = go.Figure()
@@ -38,8 +38,8 @@ def plot_volatility_smile(moneyness_array: np.ndarray,
     )
 
     # 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 option_chain is not None and maturity is not None:
+        maturity_data = option_chain[option_chain['maturity_name'] == maturity]
 
         if not maturity_data.empty:
             # Add bid and ask IVs
@@ -72,13 +72,13 @@ def plot_volatility_smile(moneyness_array: np.ndarray,
 @catch_exception
 def plot_all_smiles(moneyness_array: np.ndarray,
                     iv_surface: Dict[str, np.ndarray],
-                    market_data: Optional[pd.DataFrame] = None) -> List[go.Figure]:
+                    option_chain: Optional[pd.DataFrame] = None) -> List[go.Figure]:
     """Plot volatility smiles for all expiries."""
     return [
         plot_volatility_smile(
             moneyness_array=moneyness_array,
             iv_array=iv_surface[maturity],
-            market_data=market_data,
+            option_chain=option_chain,
             maturity=maturity
         )
         for maturity in iv_surface.keys()

voly/core/fit.py

@@ -11,6 +11,7 @@ from typing import List, Tuple, Dict, Optional, Union, Any
 from scipy.optimize import least_squares
 from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
 from voly.utils.logger import logger, catch_exception
+from voly.formulas import get_x_domain
 from voly.exceptions import VolyError
 from voly.models import SVIModel
 import warnings
@@ -19,17 +20,17 @@ 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, option_chain: pd.DataFrame,
                         model: Any = SVIModel) -> np.ndarray:
     """Calculate residuals between market and model implied volatilities."""
-    maturity_data = market_data[market_data['ytm'] == ytm]
+    maturity_data = option_chain[option_chain['ytm'] == ytm]
     w = np.array([model.svi(x, *params) for x in maturity_data['log_moneyness']])
     iv_actual = maturity_data['mark_iv'].values
     return iv_actual - np.sqrt(w / ytm)
 
 
 @catch_exception
-def fit_model(market_data: pd.DataFrame,
+def fit_model(option_chain: pd.DataFrame,
               model_name: str = 'svi',
               initial_params: Optional[List[float]] = None,
               param_bounds: Optional[Tuple] = None) -> Tuple[pd.DataFrame, pd.DataFrame]:
@@ -56,8 +57,8 @@ def fit_model(market_data: pd.DataFrame,
                          '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]
+    unique_ytms = sorted(option_chain['ytm'].unique())
+    maturity_names = [option_chain[option_chain['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)
@@ -68,7 +69,7 @@ def fit_model(market_data: pd.DataFrame,
 
     for ytm in unique_ytms:
         # Get data for this maturity
-        maturity_data = market_data[market_data['ytm'] == ytm]
+        maturity_data = option_chain[option_chain['ytm'] == ytm]
         maturity_name = maturity_data['maturity_name'].iloc[0]
         dtm = maturity_data['dtm'].iloc[0]
 
@@ -79,7 +80,7 @@ def fit_model(market_data: pd.DataFrame,
             result = least_squares(
                 calculate_residuals,
                 initial_params,
-                args=(ytm, market_data, SVIModel),
+                args=(ytm, option_chain, SVIModel),
                 bounds=param_bounds,
                 max_nfev=1000
             )
@@ -136,19 +137,30 @@ def fit_model(market_data: pd.DataFrame,
 
 @catch_exception
 def get_iv_surface(fit_results: pd.DataFrame,
-                   log_moneyness_params: Tuple[float, float, int] = (-2, 2, 500)
-                   ) -> Tuple[np.ndarray, Dict[str, np.ndarray]]:
-    """Generate implied volatility surface using optimized SVI parameters."""
-    # Extract moneyness parameters
+                   log_moneyness_params: Tuple[float, float, int] = (-1.5, 1.5, 1000),
+                   return_domain: str = 'log_moneyness') -> Tuple[Dict[str, np.ndarray], np.ndarray]:
+    """
+    Generate implied volatility surface using optimized SVI parameters.
+
+    Parameters:
+    - fit_results: DataFrame from fit_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')
+
+    Returns:
+    - Tuple of (iv_surface, x_surface)
+      iv_surface: Dictionary mapping maturity names to IV arrays
+      x_surface: Dictionary mapping maturity names to requested x domain arrays
+    """
+
+    # Generate implied volatility surface in log-moneyness domain
     min_m, max_m, num_points = log_moneyness_params
+    log_moneyness_array = np.linspace(min_m, max_m, num=num_points)
 
-    # 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
+    x_surface = {}
     for maturity in fit_results.columns:
-        # Extract parameters and YTM
+        # Calculate SVI total implied variance and convert to IV
         params = [
             fit_results.loc['a', maturity],
             fit_results.loc['b', maturity],
@@ -158,8 +170,19 @@ def get_iv_surface(fit_results: pd.DataFrame,
         ]
         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)
+        w_svi = np.array([SVIModel.svi(x, *params) for x in log_moneyness_array])
+        iv_array = np.sqrt(w_svi / ytm)
+        iv_surface[maturity] = iv_array
+
+        x_domain = get_x_domain(
+            log_moneyness_params=log_moneyness_params,
+            return_domain=return_domain,
+            s=fit_results.loc['s', maturity],
+            r=fit_results.loc['r', maturity],
+            iv_array=iv_array,
+            ytm=fit_results.loc['ytm', maturity]
+        )
+
+        x_surface[maturity] = x_domain
 
-    return moneyness_array, iv_surface
+    return iv_surface, x_surface

voly/formulas.py

@@ -7,7 +7,7 @@ from scipy.stats import norm
 from typing import Tuple, Dict, Union, List, Optional
 from voly.utils.logger import catch_exception
 from voly.models import SVIModel
-from math import exp
+from typing import Tuple
 
 
 @catch_exception
@@ -276,3 +276,86 @@ 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 get_x_domain(log_moneyness_params: Tuple[float, float, int] = (-1.5, 1.5, 1000),
+                 return_domain: str = 'log_moneyness',
+                 s: float = None,
+                 r: float = None,
+                 iv_array: np.ndarray = None,
+                 ytm: float = None) -> np.ndarray:
+    """
+    Compute the x-domain for a given return type (log-moneyness, moneyness, strikes, or delta).
+
+    Parameters:
+    -----------
+    log_moneyness_params : Tuple[float, float, int],
+        Parameters for log-moneyness domain: (min_log_moneyness, max_log_moneyness, num_points).
+        Default is (-1.5, 1.5, 1000).
+    return_domain : str, optional
+        The desired domain to return. Options are 'log_moneyness', 'moneyness', 'strikes', or 'delta'.
+        Default is 'log_moneyness'.
+    s : float, optional
+        Spot price of the underlying asset. Required for 'strikes' and 'delta' domains.
+    r : float, optional
+        Risk-free interest rate. Required for 'delta' domain.
+    iv_array : np.ndarray, optional
+        Array of implied volatilities. Required for 'delta' domain.
+    ytm : float, optional
+        Time to maturity in years. Required for 'delta' domain.
+
+    Returns:
+    --------
+    np.ndarray
+        The x-domain array corresponding to the specified return_domain.
+
+    Raises:
+    -------
+    ValueError
+        If required parameters are missing for the specified return_domain.
+    """
+
+    # Extract log-moneyness parameters
+    min_m, max_m, num_points = log_moneyness_params
+
+    # Generate the base log-moneyness array
+    log_moneyness = np.linspace(min_m, max_m, num_points)
+
+    # Handle different return domains
+    if return_domain == 'log_moneyness':
+        return log_moneyness
+
+    elif return_domain == 'moneyness':
+        return np.exp(log_moneyness)
+
+    elif return_domain == 'strikes':
+        if s is None:
+            raise ValueError("Spot price 's' is required for return_domain='strikes'.")
+        return s / np.exp(log_moneyness)  # K = S/exp(log_moneyness)
+
+    elif return_domain == 'delta':
+        # Check for required parameters
+        required_params = {'s': s, 'r': r, 'iv_array': iv_array, 'ytm': ytm}
+        missing_params = [param for param, value in required_params.items() if value is None]
+        if missing_params:
+            raise ValueError(f"The following parameters are required for return_domain='delta': {missing_params}")
+
+        if len(iv_array) != len(log_moneyness):
+            raise ValueError(
+                f"iv_array must have the same length as the log-moneyness array ({len(log_moneyness)}).")
+
+        # Compute strikes
+        strikes = s / np.exp(log_moneyness)
+
+        # Compute deltas
+        delta_values = np.array([
+            delta(s, k, r, vol, ytm, 'call')
+            for k, vol in zip(strikes, iv_array)
+        ])
+
+        return delta_values
+
+    else:
+        raise ValueError(
+            f"Invalid return_domain: {return_domain}. Must be one of ['log_moneyness', 'moneyness', 'strikes', 'delta'].")

{voly-0.0.61.dist-info → voly-0.0.63.dist-info}/METADATA

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

{voly-0.0.61.dist-info → voly-0.0.63.dist-info}/RECORD

@@ -1,18 +1,18 @@
 voly/__init__.py,sha256=8xyDk7rFCn_MOD5hxuv5cxxKZvBVRiSIM7TgaMPpwpw,211
-voly/client.py,sha256=JzxVZSmb71zcB7JGicYZM-NA_gC7Jedu2SOYImxXSNY,20452
+voly/client.py,sha256=E_3bSDBQt5Kv5-NnU1noDFaj75llkBV3Wt2AxT270-k,20577
 voly/exceptions.py,sha256=PBsbn1vNMvKcCJwwJ4lBO6glD85jo1h2qiEmD7ArAjs,92
-voly/formulas.py,sha256=Xgaq4lx1fNzRfu9W84fMNeH6GRJ0FNFNUUUYn5ffjjE,8843
+voly/formulas.py,sha256=gl4L_KtSd8ZJTAc6_RroJSDwOS8z6gcnpARG7oJFxdk,11897
 voly/models.py,sha256=LXXIlpXZQEfXTuCngxC8Hd3bWtw6wdXDCSGxTLmHM-c,3659
 voly/core/__init__.py,sha256=bu6fS2I1Pj9fPPnl-zY3L7NqrZSY5Zy6NY2uMUvdhKs,183
-voly/core/charts.py,sha256=kWjd3sfvTalfuElt7vSuRPtYuWpMoJ9-L2Z9Mj-mOMQ,24374
+voly/core/charts.py,sha256=0fYD748wHUBtuOcRufzfDwjlhmLf6g081KH-zquIj0A,24381
 voly/core/data.py,sha256=e8qBArubNqPkrfuIYB_q2WhRf7TKzA4Z3FhMC-xyLEE,8862
-voly/core/fit.py,sha256=YClTiODlH9CBAqv5VNBlE0k6qD22Hwic91PnTWstyj4,6490
+voly/core/fit.py,sha256=N1wey5NYeInIPKfa5xC0P4eBVhoTf0wwu7cYMmgv-Xg,7310
 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.61.dist-info/LICENSE,sha256=wcHIVbE12jfcBOai_wqBKY6xvNQU5E909xL1zZNq_2Q,1065
-voly-0.0.61.dist-info/METADATA,sha256=4yMzNptN7516PzN07OVCD5eFTJYuL7gWFfm9o3l35Y8,4092
-voly-0.0.61.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
-voly-0.0.61.dist-info/top_level.txt,sha256=ZfLw2sSxF-LrKAkgGjOmeTcw6_gD-30zvtdEY5W4B7c,5
-voly-0.0.61.dist-info/RECORD,,
+voly-0.0.63.dist-info/LICENSE,sha256=wcHIVbE12jfcBOai_wqBKY6xvNQU5E909xL1zZNq_2Q,1065
+voly-0.0.63.dist-info/METADATA,sha256=mB6YOpRgoriXvhchIXltVimIlJDsWYSmo1uAqjVLsME,4092
+voly-0.0.63.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
+voly-0.0.63.dist-info/top_level.txt,sha256=ZfLw2sSxF-LrKAkgGjOmeTcw6_gD-30zvtdEY5W4B7c,5
+voly-0.0.63.dist-info/RECORD,,