voly 0.0.127__tar.gz → 0.0.129__tar.gz

{voly-0.0.127/src/voly.egg-info → voly-0.0.129}/PKG-INFO

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

{voly-0.0.127 → voly-0.0.129}/pyproject.toml

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

{voly-0.0.127 → voly-0.0.129}/src/voly/client.py

@@ -368,40 +368,3 @@ class VolyClient:
             'x_surface': x_surface,
             'moments': moments
         }
-
-    @staticmethod
-    def get_rv_surface(model_results: pd.DataFrame,
-                       pdf_surface: Dict[str, np.ndarray],
-                       x_surface: Dict[str, np.ndarray],
-                       domain_params: Tuple[float, float, int] = (-1.5, 1.5, 1000),
-                       return_domain: str = 'log_moneyness') -> Dict[str, Any]:
-        """
-        Transform historical density surface into a volatility surface.
-
-        Parameters:
-        - model_results: DataFrame from fit_model() with maturity information
-        - pdf_surface: Dictionary mapping maturity names to historical density arrays
-        - x_surface: Dictionary mapping maturity names to x domain arrays
-        - domain_params: Tuple of (min, max, num_points) for the log-moneyness grid
-        - return_domain: Domain for x-axis values ('log_moneyness', 'moneyness', 'returns', 'strikes', 'delta')
-
-        Returns:
-        - Dictionary with implied volatility surface information
-        """
-
-        logger.info("Calculating realized volatility surface")
-
-        # Generate the surface
-        fit_results, rv_surface, x_surface = get_rv_surface(
-            model_results=model_results,
-            pdf_surface=pdf_surface,
-            x_surface=x_surface,
-            domain_params=domain_params,
-            return_domain=return_domain
-        )
-
-        return {
-            'fit_results': fit_results,
-            'rv_surface': rv_surface,
-            'x_surface': x_surface
-        }

{voly-0.0.127 → voly-0.0.129}/src/voly/core/hd.py

@@ -205,169 +205,3 @@ def get_hd_surface(model_results: pd.DataFrame,
     moments = pd.DataFrame(all_moments).T
 
     return pdf_surface, cdf_surface, x_surface, moments
-
-
-@catch_exception
-def get_rv_surface(model_results: pd.DataFrame,
-                   pdf_surface: Dict[str, np.ndarray],
-                   x_surface: Dict[str, np.ndarray],
-                   domain_params: Tuple[float, float, int] = (-1.5, 1.5, 1000),
-                   return_domain: str = 'log_moneyness') -> Tuple[
-    Dict[str, np.ndarray], Dict[str, np.ndarray], pd.DataFrame]:
-
-    # Check if required columns are present
-    required_columns = ['s', 't', 'r']
-    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}")
-
-    rv_surface = {}
-    new_x_surface = {}
-    all_params = {}
-
-    # Check if pdf_surface is empty
-    if not pdf_surface:
-        logger.warning("Historical density surface is empty.")
-        return {}, {}, pd.DataFrame()
-
-    # Process each maturity
-    for i in model_results.index:
-        if i not in pdf_surface:
-            logger.warning(f"No historical density available for maturity {i}, skipping.")
-            continue
-
-        # Get parameters for this maturity
-        s = model_results.loc[i, 's']
-        r = model_results.loc[i, 'r']
-        t = model_results.loc[i, 't']
-
-        # Get historical density for this maturity
-        pdf = pdf_surface[i]
-        x = x_surface[i]
-
-        # Calculate x_domain grids
-        LM = get_domain(domain_params, s, r, None, t, 'log_moneyness')
-        M = get_domain(domain_params, s, r, None, t, 'moneyness')
-        R = get_domain(domain_params, s, r, None, t, 'returns')
-        K = get_domain(domain_params, s, r, None, t, 'log_moneyness')
-
-        # Recover call prices from the PDF
-        c_recovered = np.zeros_like(LM)
-        for j, lm_k in enumerate(LM):
-            mask = LM >= lm_k
-            if np.any(mask):
-                integrand = s * (np.exp(LM[mask]) - np.exp(lm_k)) * pdf[mask]
-                c_recovered[j] = np.exp(-r * t) * np.trapz(integrand, LM[mask])
-
-        # Ensure call prices are at least the intrinsic value
-        intrinsic_values = np.maximum(s - K, 0)
-        c_recovered = np.maximum(c_recovered, intrinsic_values)
-
-        # Determine min_lm and max_lm based on days to expiry (DTE)
-        dte = t * 365.25
-        if dte <= 30:
-            min_lm, max_lm = -0.3, 0.3
-        elif dte <= 90:
-            min_lm, max_lm = -0.6, 0.6
-        else:
-            min_lm, max_lm = -0.9, 0.9
-
-        # Generate key log-moneyness points
-        key_lm_points = generate_lm_points(min_lm, max_lm)
-
-        # Find the indices of the key log-moneyness points
-        key_indices = [np.argmin(np.abs(LM - lm)) for lm in key_lm_points]
-        key_lm_actual = LM[key_indices]  # Actual log moneyness values
-        key_strikes = K[key_indices]  # Corresponding strikes
-
-        # Extract call prices at key log-moneyness points
-        key_call_prices = c_recovered[key_indices]
-
-        # Compute IV at key log-moneyness points using our own iv function
-        key_ivs = []
-        for j, idx in enumerate(key_indices):
-            call_price = key_call_prices[j]
-            strike = key_strikes[j]
-            if call_price <= 0:
-                iv_value = 0.01  # Minimum IV of 1%
-            else:
-                try:
-                    iv_value = iv(option_price=call_price, s=s, K=strike, r=r, t=t, option_type='call')
-                    iv_value = max(0.01, min(iv_value, 3.0))  # Clamp between 1% and 300%
-                except Exception as e:
-                    logger.warning(f"IV calculation failed for strike {strike}: {str(e)}")
-                    iv_value = 0.01  # Fallback to 1%
-            key_ivs.append(iv_value)
-        key_ivs = np.array(key_ivs)
-
-        # Create a synthetic option chain for SVI fitting
-        # Convert to DataFrame columns that fit_model expects
-        synthetic_chain = pd.DataFrame({
-            'maturity_name': [i] * len(key_strikes),
-            'maturity_date': pd.Timestamp.now() + pd.Timedelta(days=int(t * 365.25)),
-            'index_price': s,
-            'underlying_price': s,
-            'strike': key_strikes,
-            'log_moneyness': key_lm_actual,
-            'mark_iv': key_ivs,
-            't': t,
-            'r': r,
-            'option_type': 'call'
-        })
-
-        # Fit the SVI model to the recovered IVs
-        fit_results_rv = fit_model(option_chain=synthetic_chain, model_name='svi')
-
-        # Get the parameters for this maturity
-        a = fit_results_rv.loc[i, 'a']
-        b = fit_results_rv.loc[i, 'b']
-        sigma = fit_results_rv.loc[i, 'sigma']
-        rho = fit_results_rv.loc[i, 'rho']
-        m = fit_results_rv.loc[i, 'm']
-
-        # Store the parameters
-        params = {
-            's': s,
-            'r': r,
-            't': t,
-            'a': a,
-            'b': b,
-            'sigma': sigma,
-            'rho': rho,
-            'm': m
-        }
-
-        nu, psi, p, c, nu_tilde = SVIModel.raw_to_jw_params(params['a'], params['b'], params['sigma'], params['rho'], params['m'], params['t'])
-        params.update({
-            'nu': nu,
-            'psi': psi,
-            'p': p,
-            'c': c,
-            'nu_tilde': nu_tilde,
-        })
-        all_params[i] = params
-
-        # Calculate implied volatility using SVI model
-        w = np.array([SVIModel.svi(lm, a, b, sigma, rho, m) for lm in LM])
-        o_recovered = np.sqrt(w / t)
-
-        # Store results
-        rv_surface[i] = o_recovered
-
-        if return_domain == 'log_moneyness':
-            x = LM
-        elif return_domain == 'moneyness':
-            x = M
-        elif return_domain == 'returns':
-            x = R
-        elif return_domain == 'strikes':
-            x = K
-        elif return_domain == 'delta':
-            x = get_domain(domain_params, s, r, o_recovered, t, 'delta')
-
-        new_x_surface[i] = x
-
-    # Create a DataFrame with parameters
-    fit_results = pd.DataFrame(all_params).T
-    x_surface = new_x_surface
-    return fit_results, rv_surface, x_surface

{voly-0.0.127 → voly-0.0.129}/src/voly/formulas.py

@@ -43,6 +43,7 @@ def d1(s: float, K: float, r: float, o: float, t: float, option_type: str = 'cal
         return np.nan
     return (np.log(s / K) + (r + o ** 2 / 2) * t) / (o * np.sqrt(t))
 
+
 @catch_exception
 @vectorize_inputs
 def d2(s: float, K: float, r: float, o: float, t: float, option_type: str = 'call') -> float:

{voly-0.0.127 → voly-0.0.129}/src/voly/models.py

@@ -5,6 +5,7 @@ Volatility models for the Voly package.
 import numpy as np
 from typing import Tuple, Dict, List, Optional, Union
 
+
 class SVIModel:
     """
     Stochastic Volatility Inspired (SVI) model.

{voly-0.0.127 → voly-0.0.129/src/voly.egg-info}/PKG-INFO

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