voly 0.0.11__py3-none-any.whl → 0.0.13__py3-none-any.whl

voly/client.py

@@ -18,7 +18,7 @@ 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
+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.interpolate import interpolate_model
 from voly.core.charts import (
@@ -295,18 +295,16 @@ class VolyClient:
     @staticmethod
     def fit_model(market_data: pd.DataFrame,
                   model_name: str = 'svi',
-                  moneyness_range: Tuple[float, float] = (-2, 2),
-                  num_points: int = 500,
-                  plot: bool = False) -> Dict[str, Any]:
+                  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: Name of model to fit (default: 'svi')
-        - moneyness_range: (min, max) range for moneyness grid
-        - num_points: Number of points for moneyness grid
-        - plot: Whether to generate and return plots
+        - initial_params: Optional initial parameters for optimization
+        - param_bounds: Optional parameter bounds for optimization
 
         Returns:
         - Dictionary with fitting results and optional plots
@@ -317,18 +315,38 @@ class VolyClient:
         fit_results = fit_model(
             market_data=market_data,
             model_name=model_name,
-            moneyness_range=moneyness_range,
-            num_points=num_points
+            initial_params=initial_params,
+            param_bounds=param_bounds
         )
 
-        # Generate plots if requested
-        if plot:
-            logger.info("Generating model fitting plots")
-            plots = generate_all_plots(fit_results, market_data=market_data)
-            fit_results['plots'] = plots
-
         return fit_results
 
+    @staticmethod
+    def get_surface(param_matrix: pd.DataFrame,
+                    log_moneyness: 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['raw_param_matrix']
+        - log_moneyness: Tuple of (min, max, num_points) for the moneyness grid
+
+        Returns:
+        - Dictionary with surface generation results
+        """
+        logger.info("Generating implied volatility surface")
+
+        # Generate the surface
+        moneyness_grid, iv_surface = get_surface(
+            param_matrix=param_matrix,
+            log_moneyness=log_moneyness
+        )
+
+        return {
+            'moneyness_grid': moneyness_grid,
+            'iv_surface': iv_surface
+        }
+
     # -------------------------------------------------------------------------
     # Risk-Neutral Density (RND)
     # -------------------------------------------------------------------------

voly/core/data.py

@@ -174,7 +174,7 @@ async def get_deribit_data(currency: str = "BTC") -> pd.DataFrame:
         raise ConnectionError(f"WebSocket connection error: {str(e)}")
 
     total_time = time.time() - total_start
-    logger.info(f"Total processing time: {total_time:.2f}s - {len(all_data)} instruments processed")
+    logger.info(f"Total fetching time: {total_time:.2f}s")
 
     if not all_data:
         raise VolyError("No data collected from Deribit")
@@ -195,7 +195,7 @@ def process_option_chain(df: pd.DataFrame, currency: str, min_dte: float = 2.0)
     Returns:
     pd.DataFrame: Processed option chain data
     """
-    logger.info(f"Processing option chain data for {currency}...")
+    logger.info(f"Processing data for {currency}...")
 
     # Extract instrument details
     # Format is typically BTC-DDMMMYY-STRIKE-C/P or ETH-DDMMMYY-STRIKE-C/P
@@ -248,10 +248,7 @@ def process_option_chain(df: pd.DataFrame, currency: str, min_dte: float = 2.0)
     # Calculate log-moneyness
     df['log_moneyness'] = np.log(df['underlying_price'] / df['strike'])
 
-    # Remove rows with missing implied volatility
-    original_rows = len(df)
-    df = df.dropna(subset=['mark_iv', 'log_moneyness', 'yte'])
-    logger.info(f"Removed {original_rows - len(df)} rows with missing data")
+    logger.info(f"Processing complete!")
 
     return df
 

voly/core/fit.py

@@ -13,6 +13,9 @@ from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
 from voly.utils.logger import logger, catch_exception
 from voly.exceptions import VolyError
 from voly.models import SVIModel
+import warnings
+
+warnings.filterwarnings("ignore")
 
 
 @catch_exception
@@ -48,11 +51,11 @@ def calculate_residuals(params: List[float],
 
 
 @catch_exception
-def optimize_svi_parameters(market_data: pd.DataFrame,
-                            initial_params: Optional[List[float]] = None,
-                            param_bounds: Optional[Tuple] = None) -> Dict[str, Dict[str, Any]]:
+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]]:
     """
-    Optimize SVI parameters for all unique expiries in the market data.
+    Fit SVI parameters for all unique expiries in the market data.
 
     Parameters:
     - market_data: DataFrame with market data
@@ -60,11 +63,8 @@ def optimize_svi_parameters(market_data: pd.DataFrame,
     - param_bounds: Bounds for parameters (default: from SVIModel)
 
     Returns:
-    - Dictionary of optimization results by maturity name
+    - Tuple of (fit_performance DataFrame, params_dict)
     """
-    results = {}
-    unique_expiries = sorted(market_data['yte'].unique())
-
     # Use defaults if not provided
     if initial_params is None:
         initial_params = SVIModel.DEFAULT_INITIAL_PARAMS
@@ -72,37 +72,78 @@ def optimize_svi_parameters(market_data: pd.DataFrame,
     if param_bounds is None:
         param_bounds = SVIModel.DEFAULT_PARAM_BOUNDS
 
-    for t_dte in unique_expiries:
+    # Initialize data for fit performance
+    fit_data = {
+        'Maturity': [],
+        'DTE': [],
+        'YTE': [],
+        'Success': [],
+        'Cost': [],
+        'Optimality': [],
+        'RMSE': [],
+        'MAE': [],
+        'R²': [],
+        'Max Error': [],
+        'Number of Points': []
+    }
+
+    # Dictionary to store parameters
+    params_dict = {}
+
+    # Get unique expiries
+    unique_expiries = sorted(market_data['yte'].unique())
+
+    for yte in unique_expiries:
         # Get maturity name for reporting
-        expiry_data = market_data[market_data['yte'] == t_dte]
+        expiry_data = market_data[market_data['yte'] == yte]
         maturity_name = expiry_data['maturity_name'].iloc[0]
         dte_value = expiry_data['dte'].iloc[0]
 
-        logger.info(f"Optimizing for {maturity_name} (DTE: {dte_value:.1f}, YTE: {t_dte:.4f})...")
+        logger.info(f"Optimizing for {maturity_name} (DTE: {dte_value:.1f})...")
 
         # Optimize SVI parameters
         try:
             result = least_squares(
                 calculate_residuals,
                 initial_params,
-                args=(t_dte, market_data, SVIModel),
+                args=(yte, market_data, SVIModel),
                 bounds=param_bounds,
                 max_nfev=1000
             )
         except Exception as e:
             raise VolyError(f"Optimization failed for {maturity_name}: {str(e)}")
 
-        # Store results with maturity name as key
-        results[maturity_name] = {
-            'params': result.x,
-            'success': result.success,
-            'cost': result.cost,
-            'optimality': result.optimality,
-            'message': result.message,
-            'yte': t_dte,
+        # Get parameters
+        params = result.x
+        params_dict[maturity_name] = {
+            'params': params,
             'dte': dte_value
         }
 
+        # Calculate model predictions for statistics
+        w_svi = np.array([SVIModel.svi(x, *params) for x in expiry_data['log_moneyness']])
+        iv_model = np.sqrt(w_svi / yte)
+        iv_market = expiry_data['mark_iv'].values
+
+        # Calculate statistics
+        rmse = np.sqrt(mean_squared_error(iv_market, iv_model))
+        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(expiry_data)
+
+        # Add to fit data
+        fit_data['Maturity'].append(maturity_name)
+        fit_data['DTE'].append(dte_value)
+        fit_data['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['R²'].append(r2)
+        fit_data['Max Error'].append(max_error)
+        fit_data['Number of Points'].append(num_points)
+
         if result.success:
             logger.info(f'Optimization for {maturity_name} (DTE: {dte_value:.1f}): SUCCESS')
         else:
@@ -110,17 +151,20 @@ def optimize_svi_parameters(market_data: pd.DataFrame,
 
         logger.info('------------------------------------------')
 
-    return results
+    # Create DataFrame with all fit performance data
+    fit_performance = pd.DataFrame(fit_data)
+
+    return fit_performance, params_dict
 
 
 @catch_exception
-def create_parameters_matrix(optimization_results: Dict[str, Dict[str, Any]]) -> Tuple[pd.DataFrame, pd.DataFrame]:
+def create_parameters_matrix(params_dict: Dict[str, Dict]) -> Tuple[pd.DataFrame, pd.DataFrame]:
     """
     Create matrices of optimized parameters for each expiry.
     Uses maturity names as column names.
 
     Parameters:
-    - optimization_results: Dictionary of optimization results by maturity name
+    - params_dict: Dictionary of parameter results by maturity name
 
     Returns:
     - Tuple of DataFrames with optimized parameters:
@@ -128,8 +172,8 @@ def create_parameters_matrix(optimization_results: Dict[str, Dict[str, Any]]) ->
       2. Jump-Wing parameters (nu, psi, p, c, nu_tilde)
     """
     # Get maturity names in order by DTE
-    maturity_names = sorted(optimization_results.keys(),
-                            key=lambda x: optimization_results[x]['dte'])
+    maturity_names = sorted(params_dict.keys(),
+                            key=lambda x: params_dict[x]['dte'])
 
     # Create DataFrame for raw parameters with maturity names as columns
     raw_param_matrix = pd.DataFrame(
@@ -149,7 +193,7 @@ def create_parameters_matrix(optimization_results: Dict[str, Dict[str, Any]]) ->
 
     # Fill the matrices with optimized parameters
     for maturity_name in maturity_names:
-        result = optimization_results[maturity_name]
+        result = params_dict[maturity_name]
 
         # Extract raw SVI parameters
         a, b, sigma, rho, m = result['params']
@@ -161,7 +205,7 @@ def create_parameters_matrix(optimization_results: Dict[str, Dict[str, Any]]) ->
         dte_values[maturity_name] = result['dte']
 
         # Calculate JW parameters
-        nu, psi, p, c, nu_tilde = SVIModel.svi_jw_params(a, b, sigma, rho, m, yte)
+        nu, psi, p, c, nu_tilde = SVIModel.raw_to_jw_params(a, b, sigma, rho, m, yte)
         jw_param_matrix[maturity_name] = [nu, psi, p, c, nu_tilde]
 
     # Store YTE and DTE as attributes in all DataFrames for reference
@@ -177,155 +221,71 @@ def create_parameters_matrix(optimization_results: Dict[str, Dict[str, Any]]) ->
 
 
 @catch_exception
-def generate_implied_volatility_surface(
-        param_matrix: pd.DataFrame,
-        moneyness_range: Tuple[float, float] = (-2, 2),
-        num_points: int = 500
-) -> Tuple[np.ndarray, Dict[float, np.ndarray]]:
-    """
-    Generate implied volatility surface using optimized SVI parameters.
-
-    Parameters:
-    - param_matrix: Matrix of optimized SVI parameters with maturity names as columns
-    - moneyness_range: (min, max) range for moneyness grid
-    - num_points: Number of points for moneyness grid
-
-    Returns:
-    - Moneyness grid and implied volatility surface
-    """
-    # Generate moneyness grid
-    min_m, max_m = moneyness_range
-    moneyness_values = np.linspace(min_m, max_m, num=num_points)
-    implied_volatility_surface = {}
-
-    # Get YTE values from the parameter matrix attributes
-    yte_values = param_matrix.attrs['yte_values']
-
-    # Generate implied volatility for each expiry
-    for maturity_name, yte in yte_values.items():
-        svi_params = param_matrix[maturity_name].values
-        w_svi = [SVIModel.svi(x, *svi_params) for x in moneyness_values]
-        implied_volatility_surface[yte] = np.sqrt(np.array(w_svi) / yte)
-
-    return moneyness_values, implied_volatility_surface
-
-
-@catch_exception
-def calculate_fit_statistics(market_data: pd.DataFrame, param_matrix: pd.DataFrame) -> pd.DataFrame:
+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]:
     """
-    Calculate fitting accuracy statistics for each expiry.
+    Fit a volatility model to market data.
 
     Parameters:
     - market_data: DataFrame with market data
-    - param_matrix: Matrix of optimized SVI parameters with maturity names as columns
+    - 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)
 
     Returns:
-    - DataFrame with fitting statistics
+    - Dictionary with fitting results
     """
-    # Get YTE values from the parameter matrix attributes
-    yte_values = param_matrix.attrs['yte_values']
-    dte_values = param_matrix.attrs['dte_values']
-
-    # Initialize lists for statistics
-    maturity_name_list = []
-    dte_list = []
-    yte_list = []
-    rmse_list = []
-    mae_list = []
-    r2_list = []
-    max_error_list = []
-    num_points_list = []
-
-    # Calculate statistics for each expiry
-    for maturity_name, yte in yte_values.items():
-        # Filter market data for the specific expiry
-        expiry_data = market_data[market_data['yte'] == yte]
-        dte_value = dte_values[maturity_name]
-
-        # Calculate SVI model predictions
-        svi_params = param_matrix[maturity_name].values
-        w_svi = np.array([SVIModel.svi(x, *svi_params) for x in expiry_data['log_moneyness']])
-        iv_model = np.sqrt(w_svi / yte)
+    if model_name.lower() != 'svi':
+        raise VolyError(f"Model type '{model_name}' is not supported. Currently only 'svi' is available.")
 
-        # Get actual market implied volatilities
-        iv_market = expiry_data['mark_iv'].values
+    # 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
+    )
 
-        # Calculate statistics
-        rmse = np.sqrt(mean_squared_error(iv_market, iv_model))
-        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(expiry_data)
+    # Step 2: Create parameter matrices
+    raw_param_matrix, jw_param_matrix = create_parameters_matrix(params_dict)
 
-        # Append to lists
-        maturity_name_list.append(maturity_name)
-        dte_list.append(dte_value)
-        yte_list.append(yte)
-        rmse_list.append(rmse)
-        mae_list.append(mae)
-        r2_list.append(r2)
-        max_error_list.append(max_error)
-        num_points_list.append(num_points)
-
-    # Create DataFrame with statistics
-    stats_df = pd.DataFrame({
-        'Maturity': maturity_name_list,
-        'DTE': dte_list,
-        'YTE': yte_list,
-        'RMSE': rmse_list,
-        'MAE': mae_list,
-        'R²': r2_list,
-        'Max Error': max_error_list,
-        'Number of Points': num_points_list
-    })
-
-    return stats_df
+    return {
+        'raw_param_matrix': raw_param_matrix,
+        'jw_param_matrix': jw_param_matrix,
+        'fit_performance': fit_performance,
+    }
 
 
 @catch_exception
-def fit_model(market_data: pd.DataFrame,
-              model_name: str = 'svi',
-              moneyness_range: Tuple[float, float] = (-2, 2),
-              num_points: int = 500) -> Dict[str, Any]:
+def get_surface(
+        param_matrix: pd.DataFrame,
+        log_moneyness: Tuple[float, float, int] = (-2, 2, 500)
+) -> Tuple[np.ndarray, Dict[float, np.ndarray], np.ndarray]:
     """
-    Fit a volatility model to market data.
+    Generate implied volatility surface using optimized SVI parameters.
 
     Parameters:
-    - market_data: DataFrame with market data
-    - model_name: Type of model to fit (default: 'svi')
-    - moneyness_range: (min, max) range for moneyness grid
-    - num_points: Number of points for moneyness grid
+    - param_matrix: Matrix of optimized SVI parameters from fit_results
+    - log_moneyness: Tuple of (min, max, num_points) for the moneyness grid
 
     Returns:
-    - Dictionary with fitting results
+    - Tuple of (moneyness_grid, iv_surface, unique_expiries)
     """
-    if model_name.lower() != 'svi':
-        raise VolyError(f"Model type '{model_name}' is not supported. Currently only 'svi' is available.")
-
-    # Step 1: Optimize model parameters
-    optimization_results = optimize_svi_parameters(market_data)
+    # Extract moneyness parameters
+    min_m, max_m, num_points = log_moneyness
 
-    # Step 2: Create parameter matrices
-    raw_param_matrix, jw_param_matrix = create_parameters_matrix(optimization_results)
-
-    # Step 3: Generate implied volatility surface
-    moneyness_grid, iv_surface = generate_implied_volatility_surface(
-        raw_param_matrix, moneyness_range, num_points
-    )
+    # Generate moneyness grid
+    moneyness_values = np.linspace(min_m, max_m, num=num_points)
+    implied_volatility_surface = {}
 
-    # Step 4: Calculate fitting statistics
-    stats_df = calculate_fit_statistics(market_data, raw_param_matrix)
+    # Get YTE values from the parameter matrix attributes
+    yte_values = param_matrix.attrs['yte_values']
 
-    # Step 5: Get unique expiries in sorted order (in years)
-    unique_expiries_years = np.array(sorted(market_data['yte'].unique()))
+    # Generate implied volatility for each expiry
+    for maturity_name, yte in yte_values.items():
+        svi_params = param_matrix[maturity_name].values
+        w_svi = [SVIModel.svi(x, *svi_params) for x in moneyness_values]
+        implied_volatility_surface[yte] = np.sqrt(np.array(w_svi) / yte)
 
-    # Return all results in a dictionary
-    return {
-        'optimization_results': optimization_results,
-        'raw_param_matrix': raw_param_matrix,
-        'jw_param_matrix': jw_param_matrix,
-        'moneyness_grid': moneyness_grid,
-        'iv_surface': iv_surface,
-        'stats_df': stats_df,
-        'unique_expiries': unique_expiries_years,
-    }
+    return moneyness_values, implied_volatility_surface

{voly-0.0.11.dist-info → voly-0.0.13.dist-info}/METADATA

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

{voly-0.0.11.dist-info → voly-0.0.13.dist-info}/RECORD

@@ -1,18 +1,18 @@
 voly/__init__.py,sha256=8xyDk7rFCn_MOD5hxuv5cxxKZvBVRiSIM7TgaMPpwpw,211
-voly/client.py,sha256=i7wPy02L1y21giYUVAQTWkCuNAwykCUAWlJ-D1pA4YM,17493
+voly/client.py,sha256=ueQnorQLNk71p_1XymuNFZvWZILxXygRnvTNeU927mg,18088
 voly/exceptions.py,sha256=PBsbn1vNMvKcCJwwJ4lBO6glD85jo1h2qiEmD7ArAjs,92
 voly/formulas.py,sha256=aG_HSq_a4j7TcuKiINlHSpmNdmfZa_fzYbAk8EGt954,7427
 voly/models.py,sha256=YJ12aamLz_-aOni4Qm0_XV9u4bjKK3vfJz0J2gc1h0o,3565
 voly/core/__init__.py,sha256=GU6l7hpxJfitPx9jnmBtcb_QIeqOO8liZsSbLXXSbq8,384
 voly/core/charts.py,sha256=GF55IS-aZfcc_0yoSPRPIPBPcJhFD1El18wNCo_mI_A,29918
-voly/core/data.py,sha256=RCvL9ZZWHgO2cfNbLSby2zNsoJmF2VCkJ0yRb1HtjHs,10171
-voly/core/fit.py,sha256=JSQuEkdriVdilcIPAJaieZUofYdCfSGJ5wVB1wRBfVs,11280
+voly/core/data.py,sha256=Dfk-ByHpdteUiLXr0p-wRLr3VAmdyjdDBKwjwdTgCjA,9939
+voly/core/fit.py,sha256=oTKb0f7ajkx3HgPmz2-Waw5RjfmD5smjZ_eYvzp74vU,9809
 voly/core/interpolate.py,sha256=ztVIePJZOh-CIbn69wkh1JW2rKywNe2FEewRN0zcSAo,8185
 voly/core/rnd.py,sha256=-xBVzvM9sMIBtfOfWyBJKtiVcBShSGTNNp2PZFOD5j0,12155
 voly/utils/__init__.py,sha256=E05mWatyC-PDOsCxQV1p5Xi1IgpOomxrNURyCx_gB-w,200
 voly/utils/logger.py,sha256=4-_2bVJmq17Q0d7Rd2mPg1AeR8gxv6EPvcmBDMFWcSM,1744
-voly-0.0.11.dist-info/LICENSE,sha256=wcHIVbE12jfcBOai_wqBKY6xvNQU5E909xL1zZNq_2Q,1065
-voly-0.0.11.dist-info/METADATA,sha256=ggw_f34HW4h4RTN5_37TpH7bW_sVJ-_AdCpVeG_Fz9Y,4092
-voly-0.0.11.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
-voly-0.0.11.dist-info/top_level.txt,sha256=ZfLw2sSxF-LrKAkgGjOmeTcw6_gD-30zvtdEY5W4B7c,5
-voly-0.0.11.dist-info/RECORD,,
+voly-0.0.13.dist-info/LICENSE,sha256=wcHIVbE12jfcBOai_wqBKY6xvNQU5E909xL1zZNq_2Q,1065
+voly-0.0.13.dist-info/METADATA,sha256=6L9wGCYqq8YDBQ1CtqdXLGWEhQM8qGQKAfEyiOCFTA8,4092
+voly-0.0.13.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
+voly-0.0.13.dist-info/top_level.txt,sha256=ZfLw2sSxF-LrKAkgGjOmeTcw6_gD-30zvtdEY5W4B7c,5
+voly-0.0.13.dist-info/RECORD,,