voly 0.0.226__py3-none-any.whl → 0.0.228__py3-none-any.whl

voly/client.py

@@ -79,7 +79,7 @@ class VolyClient:
 
         try:
             option_chain = loop.run_until_complete(
-                fetch_option_chain(exchange, currency, depth)
+                fetch_option_chain(exchange, currency)
             )
             return option_chain
         except VolyError as e:
@@ -97,68 +97,68 @@ class VolyClient:
 
     @staticmethod
     def d1(s: float, K: float, r: float, o: float, t: float,
-           option_type: str = 'call') -> float:
-        return d1(s, K, r, o, t, option_type)
+           flag: str = 'call') -> float:
+        return d1(s, K, r, o, t, flag)
 
     @staticmethod
     def d2(s: float, K: float, r: float, o: float, t: float,
-           option_type: str = 'call') -> float:
-        return d2(s, K, r, o, t, option_type)
+           flag: str = 'call') -> float:
+        return d2(s, K, r, o, t, flag)
 
     @staticmethod
     def bs(s: float, K: float, r: float, o: float, t: float,
-           option_type: str = 'call') -> float:
-        return bs(s, K, r, o, t, option_type)
+           flag: str = 'call') -> float:
+        return bs(s, K, r, o, t, flag)
 
     @staticmethod
     def delta(s: float, K: float, r: float, o: float, t: float,
-              option_type: str = 'call') -> float:
-        return delta(s, K, r, o, t, option_type)
+              flag: str = 'call') -> float:
+        return delta(s, K, r, o, t, flag)
 
     @staticmethod
     def gamma(s: float, K: float, r: float, o: float, t: float,
-              option_type: str = 'call') -> float:
-        return gamma(s, K, r, o, t, option_type)
+              flag: str = 'call') -> float:
+        return gamma(s, K, r, o, t, flag)
 
     @staticmethod
     def vega(s: float, K: float, r: float, o: float, t: float,
-             option_type: str = 'call') -> float:
-        return vega(s, K, r, o, t, option_type)
+             flag: str = 'call') -> float:
+        return vega(s, K, r, o, t, flag)
 
     @staticmethod
     def theta(s: float, K: float, r: float, o: float, t: float,
-              option_type: str = 'call') -> float:
-        return theta(s, K, r, o, t, option_type)
+              flag: str = 'call') -> float:
+        return theta(s, K, r, o, t, flag)
 
     @staticmethod
     def rho(s: float, K: float, r: float, o: float, t: float,
-            option_type: str = 'call') -> float:
-        return rho(s, K, r, o, t, option_type)
+            flag: str = 'call') -> float:
+        return rho(s, K, r, o, t, flag)
 
     @staticmethod
     def vanna(s: float, K: float, r: float, o: float, t: float,
-              option_type: str = 'call') -> float:
-        return vanna(s, K, r, o, t, option_type)
+              flag: str = 'call') -> float:
+        return vanna(s, K, r, o, t, flag)
 
     @staticmethod
     def volga(s: float, K: float, r: float, o: float, t: float,
-              option_type: str = 'call') -> float:
-        return volga(s, K, r, o, t, option_type)
+              flag: str = 'call') -> float:
+        return volga(s, K, r, o, t, flag)
 
     @staticmethod
     def charm(s: float, K: float, r: float, o: float, t: float,
-              option_type: str = 'call') -> float:
-        return charm(s, K, r, o, t, option_type)
+              flag: str = 'call') -> float:
+        return charm(s, K, r, o, t, flag)
 
     @staticmethod
     def greeks(s: float, K: float, r: float, o: float, t: float,
-               option_type: str = 'call') -> Dict[str, float]:
-        return greeks(s, K, r, o, t, option_type)
+               flag: str = 'call') -> Dict[str, float]:
+        return greeks(s, K, r, o, t, flag)
 
     @staticmethod
     def iv(option_price: float, s: float, K: float, r: float, t: float,
-           option_type: str = 'call') -> float:
-        return iv(option_price, s, K, r, t, option_type)
+           flag: str = 'call') -> float:
+        return iv(option_price, s, K, r, t, flag)
 
     # -------------------------------------------------------------------------
     # Model Fitting
@@ -235,6 +235,12 @@ class VolyClient:
         # Generate IV surface and domain
         iv_surface, x_surface = get_iv_surface(fit_results, domain_params, return_domain)
 
+        if option_chain:
+            # Create missing domains
+            option_chain['log_moneyness'] = np.log(option_chain['strikes'] / option_chain['spot_price'].iloc[0])
+            option_chain['moneyness'] = np.exp(option_chain['log_moneyness'])
+            option_chain['returns'] = df['moneyness'] - 1
+
         # Plot volatility smiles
         plots['smiles'] = plot_all_smiles(
             x_surface=x_surface,

voly/core/charts.py

@@ -62,9 +62,9 @@ def plot_volatility_smile(x_array: np.ndarray,
 
     # Add market data if provided
     if option_chain is not None and maturity is not None:
-        maturity_data = option_chain[option_chain['maturity_name'] == maturity]
+        maturity_data = option_chain[option_chain['maturity'] == maturity]
         if return_domain == 'delta':
-            maturity_data = maturity_data[maturity_data['option_type'] == 'C']
+            maturity_data = maturity_data[maturity_data['flag'] == 'C']
 
         if not maturity_data.empty:
             # Add bid and ask IVs if available
@@ -149,10 +149,10 @@ def plot_raw_parameters(fit_results: pd.DataFrame) -> go.Figure:
     )
 
     # Get maturity names from index
-    maturity_names = fit_results.index
+    maturities = fit_results.index
 
     # Create hover text with maturity info
-    tick_labels = [f"{m}" for m in maturity_names]
+    tick_labels = [f"{m}" for m in maturities]
 
     # Plot each parameter
     for i, param in enumerate(param_names):
@@ -160,7 +160,7 @@ def plot_raw_parameters(fit_results: pd.DataFrame) -> go.Figure:
 
         fig.add_trace(
             go.Scatter(
-                x=list(range(len(maturity_names))),
+                x=list(range(len(maturities))),
                 y=fit_results[param],
                 mode='lines+markers',
                 name=param,
@@ -174,8 +174,8 @@ def plot_raw_parameters(fit_results: pd.DataFrame) -> go.Figure:
 
         # Set x-axis labels
         fig.update_xaxes(
-            tickvals=list(range(len(maturity_names))),
-            ticktext=maturity_names,
+            tickvals=list(range(len(maturities))),
+            ticktext=maturities,
             tickangle=45,
             row=row, col=col
         )
@@ -212,10 +212,10 @@ def plot_jw_parameters(fit_results: pd.DataFrame) -> go.Figure:
     )
 
     # Get maturity names from index
-    maturity_names = fit_results.index
+    maturities = fit_results.index
 
     # Create hover text with maturity info
-    tick_labels = [f"{m}" for m in maturity_names]
+    tick_labels = [f"{m}" for m in maturities]
 
     # Plot each parameter
     for i, param in enumerate(param_names):
@@ -223,7 +223,7 @@ def plot_jw_parameters(fit_results: pd.DataFrame) -> go.Figure:
 
         fig.add_trace(
             go.Scatter(
-                x=list(range(len(maturity_names))),
+                x=list(range(len(maturities))),
                 y=fit_results[param],
                 mode='lines+markers',
                 name=param,
@@ -237,8 +237,8 @@ def plot_jw_parameters(fit_results: pd.DataFrame) -> go.Figure:
 
         # Set x-axis labels
         fig.update_xaxes(
-            tickvals=list(range(len(maturity_names))),
-            ticktext=maturity_names,
+            tickvals=list(range(len(maturities))),
+            ticktext=maturities,
             tickangle=45,
             row=row, col=col
         )
@@ -279,11 +279,11 @@ def plot_fit_performance(fit_results: pd.DataFrame) -> go.Figure:
     )
 
     # Get maturity names from index and create x-axis indices
-    maturity_names = fit_results.index
-    x_indices = list(range(len(maturity_names)))
+    maturities = fit_results.index
+    x_indices = list(range(len(maturities)))
 
     # Create hover labels
-    hover_labels = [f"{m}" for m in maturity_names]
+    hover_labels = [f"{m}" for m in maturities]
 
     # Plot each metric
     for metric, config in metrics.items():
@@ -309,7 +309,7 @@ def plot_fit_performance(fit_results: pd.DataFrame) -> go.Figure:
         for col in range(1, 3):
             fig.update_xaxes(
                 tickvals=x_indices,
-                ticktext=maturity_names,
+                ticktext=maturities,
                 tickangle=45,
                 row=row, col=col
             )
@@ -352,27 +352,27 @@ def plot_3d_surface(x_surface: Dict[str, np.ndarray],
     }
 
     # Get maturity names and sort by YTM
-    maturity_names = list(iv_surface.keys())
+    maturities = list(iv_surface.keys())
     if fit_results is not None:
-        maturity_values = [fit_results.loc[name, 't'] for name in maturity_names]
+        maturity_values = [fit_results.loc[name, 't'] for name in maturities]
         # Sort by maturity
         sorted_indices = np.argsort(maturity_values)
-        maturity_names = [maturity_names[i] for i in sorted_indices]
+        maturities = [maturities[i] for i in sorted_indices]
         maturity_values = [maturity_values[i] for i in sorted_indices]
     else:
-        maturity_values = list(range(len(maturity_names)))
+        maturity_values = list(range(len(maturities)))
 
     # Create a common x-grid for all maturities
     # Use 100 points between the min and max x-values across all maturities
-    all_x = np.concatenate([x_surface[m] for m in maturity_names])
+    all_x = np.concatenate([x_surface[m] for m in maturities])
     x_min, x_max = np.min(all_x), np.max(all_x)
     x_grid = np.linspace(x_min, x_max, 400)
 
     # Create a matrix for the surface
-    z_matrix = np.zeros((len(maturity_names), len(x_grid)))
+    z_matrix = np.zeros((len(maturities), len(x_grid)))
 
     # Fill the matrix with interpolated IV values
-    for i, maturity in enumerate(maturity_names):
+    for i, maturity in enumerate(maturities):
         x_values = x_surface[maturity]
         iv_values = iv_surface[maturity] * 100  # Convert to percentage
 

voly/core/data.py

@@ -181,7 +181,7 @@ async def get_deribit_data(currency: str = "BTC") -> pd.DataFrame:
 
     return pd.DataFrame(all_data)
 
-
+'''
 @catch_exception
 def process_option_chain(df: pd.DataFrame, currency: str) -> pd.DataFrame:
     """
@@ -232,124 +232,100 @@ def process_option_chain(df: pd.DataFrame, currency: str) -> pd.DataFrame:
     logger.info(f"Processing complete!")
 
     return df
+'''
 
 
 @catch_exception
-def process_order_book_depth(option_chain, max_depth=5):
+def process_option_chain(df: pd.DataFrame, currency: str) -> pd.DataFrame:
     """
-    Process the order book depth data to enhance option pricing and weighting.
+    Process raw option chain data into a standardized format.
 
-    Args:
-        option_chain: DataFrame containing option data with 'bids' and 'asks' columns
-        max_depth: Maximum number of levels to consider from the order book
+    Parameters:
+    df (pd.DataFrame): Raw option chain data
+    currency (str): Currency code (e.g., 'BTC', 'ETH')
 
     Returns:
-        Enhanced option_chain with additional columns for depth analysis
+    pd.DataFrame: Processed option chain data
     """
-    # Create new columns for depth analysis
-    option_chain['vwap_bid'] = float('nan')
-    option_chain['vwap_ask'] = float('nan')
-    option_chain['vwap_mid'] = float('nan')
-    option_chain['depth_bid_qty'] = float('nan')
-    option_chain['depth_ask_qty'] = float('nan')
-    option_chain['vwap_bid_iv'] = float('nan')
-    option_chain['vwap_ask_iv'] = float('nan')
-    option_chain['vwap_mid_iv'] = float('nan')
-    option_chain['depth_liquidity'] = float('nan')
-
-    for idx, row in option_chain.iterrows():
-        s = row['underlying_price']
-        k = row['strikes']
-        t = row['t']
-        r = row['interest_rate'] if 'interest_rate' in row else 0.0
-        option_type = 'C' if row['option_type'] == 'call' else 'P'
+    logger.info(f"Processing data for {currency}...")
+
+    # Apply extraction to create new columns
+    df['spot_price'] = df['index_price']
+    df['instrument'] = df['instrument_name']
+    splits = df['instrument'].str.split('-')
+    df['maturity'] = splits.str[1]
+    if currency == 'XRP':
+        df['strikes'] = splits.str[2].str.replace('d', '.', regex=False).astype(float)
+    else:
+        df['strikes'] = splits.str[2].astype(float)
+    df['flag'] = splits.str[3]
+
+    # Create maturity date at 8:00 AM UTC
+    df['expiry'] = pd.to_datetime(df['maturity'].apply(
+        lambda x: int(dt.datetime.strptime(x, "%d%b%y")
+                      .replace(hour=8, minute=0, second=0, tzinfo=dt.timezone.utc)
+                      .timestamp() * 1000)), unit='ms')
 
+    # Calculate implied volatility (convert from percentage)
+    df['mark_iv'] = df['mark_iv'] / 100
+    df['bid_iv'] = df['bid_iv'].replace({0: np.nan}) / 100
+    df['ask_iv'] = df['ask_iv'].replace({0: np.nan}) / 100
+
+    df['bid_price'] = df['best_bid_price']
+    df['ask_price'] = df['best_ask_price']
+    df['bid_amount'] = df['best_bid_amount']
+    df['ask_amount'] = df['best_ask_amount']
+
+    for idx, row in df.iterrows():
         # Process bid side
         if 'bids' in row and isinstance(row['bids'], list) and len(row['bids']) > 0:
-            # Clean up the bid data
-            clean_bids = []
-            for bid in row['bids'][:max_depth]:  # Limit to max_depth levels
+            clean_bids = [] # Clean up the bid data
+            for bid in row['bids']:
                 if len(bid) >= 3:
                     # Extract price and quantity, removing 'new' if present
                     price = float(bid[1]) if bid[0] == 'new' else float(bid[0])
                     qty = float(bid[2]) if bid[0] == 'new' else float(bid[1])
                     clean_bids.append((price, qty))
-
             if clean_bids:
-                # Calculate volume-weighted average price
-                total_qty = sum(qty for _, qty in clean_bids)
-                vwap_bid = sum(price * qty for price, qty in clean_bids) / total_qty if total_qty > 0 else float('nan')
-
-                # Calculate IV for VWAP
-                try:
-                    vwap_bid_iv = voly.iv(vwap_bid * s, s, k, r, t, option_type)
-                except:
-                    vwap_bid_iv = float('nan')
-
-                option_chain.at[idx, 'vwap_bid'] = vwap_bid
-                option_chain.at[idx, 'depth_bid_qty'] = total_qty
-                option_chain.at[idx, 'vwap_bid_iv'] = vwap_bid_iv
+                df.at[idx, 'bids'] = clean_bids
 
         # Process ask side
         if 'asks' in row and isinstance(row['asks'], list) and len(row['asks']) > 0:
-            # Clean up the ask data
-            clean_asks = []
-            for ask in row['asks'][:max_depth]:  # Limit to max_depth levels
+            clean_asks = [] # Clean up the ask data
+            for ask in row['asks']:
                 if len(ask) >= 3:
                     # Extract price and quantity, removing 'new' if present
                     price = float(ask[1]) if ask[0] == 'new' else float(ask[0])
                     qty = float(ask[2]) if ask[0] == 'new' else float(ask[1])
                     clean_asks.append((price, qty))
-
             if clean_asks:
-                # Calculate volume-weighted average price
-                total_qty = sum(qty for _, qty in clean_asks)
-                vwap_ask = sum(price * qty for price, qty in clean_asks) / total_qty if total_qty > 0 else float('nan')
-
-                # Calculate IV for VWAP
-                try:
-                    vwap_ask_iv = voly.iv(vwap_ask * s, s, k, r, t, option_type)
-                except:
-                    vwap_ask_iv = float('nan')
-
-                option_chain.at[idx, 'vwap_ask'] = vwap_ask
-                option_chain.at[idx, 'depth_ask_qty'] = total_qty
-                option_chain.at[idx, 'vwap_ask_iv'] = vwap_ask_iv
-
-        # Calculate mid VWAP if both bid and ask are available
-        if not np.isnan(option_chain.at[idx, 'vwap_bid']) and not np.isnan(option_chain.at[idx, 'vwap_ask']):
-            vwap_mid = (option_chain.at[idx, 'vwap_bid'] + option_chain.at[idx, 'vwap_ask']) / 2
+                df.at[idx, 'asks'] = clean_asks
 
-            # Calculate IV for mid VWAP
-            try:
-                vwap_mid_iv = voly.iv(vwap_mid * s, s, k, r, t, option_type)
-            except:
-                vwap_mid_iv = float('nan')
+    df['bid_depth'] = df['bids']
+    df['ask_depth'] = df['asks']
+    df['open_interest'] = df['open_interest'] * df['spot_price']
+    df['volume'] = df['volume_usd']
 
-            option_chain.at[idx, 'vwap_mid'] = vwap_mid
-            option_chain.at[idx, 'vwap_mid_iv'] = vwap_mid_iv
+    df = df[['currency', 'spot_price',
+             'timestamp', 'instrument', 'maturity', 'strikes', 'flag', 'expiry',
+             'mark_iv', 'bid_iv', 'ask_iv', 'mark_price', 'bid_price', 'ask_price', 'bid_amount', 'ask_amount', 'bid_depth', 'ask_depth',
+             'delta', 'gamma', 'vega', 'theta', 'rho',
+             'interest_rate', 'open_interest', 'volume']]
 
-        # Calculate depth liquidity (sum of bid and ask quantities)
-        bid_qty = option_chain.at[idx, 'depth_bid_qty'] if not np.isnan(option_chain.at[idx, 'depth_bid_qty']) else 0
-        ask_qty = option_chain.at[idx, 'depth_ask_qty'] if not np.isnan(option_chain.at[idx, 'depth_ask_qty']) else 0
-        option_chain.at[idx, 'depth_liquidity'] = bid_qty + ask_qty
-
-    option_chain = option_chain.replace(float('inf'), float('nan'))
+    logger.info(f"Processing complete!")
 
-    return option_chain
+    return df
 
 
 @catch_exception
 async def fetch_option_chain(exchange: str = 'deribit',
-                             currency: str = 'BTC',
-                             depth: bool = False) -> pd.DataFrame:
+                             currency: str = 'BTC') -> pd.DataFrame:
     """
     Fetch option chain data from the specified exchange.
 
     Parameters:
     exchange (str): Exchange to fetch data from (currently only 'deribit' is supported)
     currency (str): Currency to fetch options for (e.g., 'BTC', 'ETH')
-    depth (bool): Whether to include full order book depth. Else, just top of book.
 
     Returns:
     pd.DataFrame: Processed option chain data
@@ -370,8 +346,4 @@ async def fetch_option_chain(exchange: str = 'deribit',
     # Process data
     processed_data = process_option_chain(raw_data, currency)
 
-    # Remove order book depth if not needed
-    if not depth and 'bids' in processed_data.columns and 'asks' in processed_data.columns:
-        processed_data = processed_data.drop(columns=['bids', 'asks'])
-
     return processed_data

voly/core/fit.py

@@ -26,16 +26,16 @@ class SVICalibrator:
     def __init__(self, option_chain, currency, num_points=2000):
         self.option_chain = option_chain
         self.currency = currency
-        self.s = option_chain['index_price'].iloc[0]
+        self.s = option_chain['spot_price'].iloc[0]
         self.r = option_chain['interest_rate'].iloc[0] if 'interest_rate' in option_chain else 0.0
-        self.groups = option_chain.groupby('maturity_date')
+        self.groups = option_chain.groupby('expiry')
         self.params_dict = {}
         self.results_data = {}
         self.num_points = num_points
 
         # Initialize results data template
         self.field_names = [
-            's', 't', 'r', 'maturity_date', 'maturity_name', 'a', 'b', 'm', 'rho', 'sigma',
+            's', 't', 'r', 'expiry', 'maturity', 'a', 'b', 'm', 'rho', 'sigma',
             'nu', 'psi', 'p', 'c', 'nu_tilde', 'log_min_strike', 'usd_min_strike',
             'fit_success', 'butterfly_arbitrage_free', 'calendar_arbitrage_free',
             'rmse', 'mae', 'r2', 'max_error', 'loss', 'n_points'
@@ -45,14 +45,14 @@ class SVICalibrator:
         for field in self.field_names:
             self.results_data[field] = []
 
-    def failed_calibration(self, maturity, maturity_name, t, n_points):
+    def failed_calibration(self, expiry, maturity, t, n_points):
         """Create an empty result for failed calibration"""
         return {
             's': float(self.s),
             't': float(t),
             'r': float(self.r),
-            'maturity_date': maturity,
-            'maturity_name': maturity_name,
+            'expiry': expiry,
+            'maturity': maturity,
             'fit_success': False,
             'calendar_arbitrage_free': True,  # Updated later
             'loss': float(np.inf),
@@ -67,7 +67,7 @@ class SVICalibrator:
     def filter_market_data(self, group):
         """Filter and prepare market data"""
         # Filter for call options only
-        group = group[group['option_type'] == 'C']
+        group = group[group['flag'] == 'C']
 
         # Handle duplicated IVs by keeping the row closest to log_moneyness=0
         duplicated_iv = group[group.duplicated('mark_iv', keep=False)]
@@ -81,7 +81,7 @@ class SVICalibrator:
             group = pd.concat([unique_iv, cleaned_dupes])
 
         # Extract basic data
-        maturity_name = group['maturity_name'].iloc[0]
+        maturity = group['maturity'].iloc[0]
         t = group['t'].iloc[0]
         K = group['strikes'].values
         iv = group['mark_iv'].values
@@ -93,7 +93,7 @@ class SVICalibrator:
         mask = ~np.isnan(w) & ~np.isnan(vega) & ~np.isnan(k) & (iv >= 0)
         k, w, vega, iv, K = k[mask], w[mask], vega[mask], iv[mask], K[mask]
 
-        return maturity_name, t, k, w, vega, iv, K
+        return maturity, t, k, w, vega, iv, K
 
     def calculate_model_stats(self, params, t, k, iv):
         """Calculate all model statistics from parameters"""
@@ -139,14 +139,14 @@ class SVICalibrator:
             'max_error': float(max_error)
         }
 
-    def process_maturity(self, maturity, group):
+    def process_maturity(self, expiry, group):
         """Process single maturity for SVI calibration"""
         # Clean and prepare market data
-        maturity_name, t, k, w, vega, iv, K = self.filter_market_data(group)
+        maturity, t, k, w, vega, iv, K = self.filter_market_data(group)
 
         # Not enough data points for fitting
         if len(k) <= 5:
-            result = self.failed_calibration(maturity, maturity_name, t, len(k))
+            result = self.failed_calibration(expiry, maturity, t, len(k))
             logger.error(f'\033[31mFAILED\033[0m for {maturity} (insufficient data points)')
             self.update_results(result)
             return maturity
@@ -156,7 +156,7 @@ class SVICalibrator:
 
         # If fitting failed
         if np.isnan(params[0]):
-            result = self.failed_calibration(maturity, maturity_name, t, len(k))
+            result = self.failed_calibration(expiry, maturity, t, len(k))
             logger.error(f'\033[31mFAILED\033[0m for {maturity}')
             self.update_results(result)
             return maturity
@@ -172,8 +172,8 @@ class SVICalibrator:
             's': float(self.s),
             't': float(t),
             'r': float(self.r),
-            'maturity_date': maturity,
-            'maturity_name': maturity_name,
+            'expiry': expiry,
+            'maturity': maturity,
             'fit_success': True,
             'calendar_arbitrage_free': True,  # Updated later
             'loss': float(loss),
@@ -201,16 +201,16 @@ class SVICalibrator:
         # Process all maturities in parallel
         with ThreadPoolExecutor() as executor:
             futures = [
-                executor.submit(self.process_maturity, maturity, group)
-                for maturity, group in self.groups
+                executor.submit(self.process_maturity, expiry, group)
+                for expiry, group in self.groups
             ]
             for future in futures:
                 future.result()
 
         # Create results DataFrame and mapping for updates
-        fit_results = pd.DataFrame(self.results_data, index=self.results_data['maturity_name'])
+        fit_results = pd.DataFrame(self.results_data, index=self.results_data['maturity'])
         fit_results = fit_results.sort_values(by='t')
-        maturity_name_dict = {row['maturity_date']: idx for idx, row in fit_results.iterrows()}
+        maturity_dict = {row['expiry']: idx for idx, row in fit_results.iterrows()}
 
         # Check for calendar arbitrage
         sorted_maturities = sorted(self.params_dict.keys(), key=lambda x: self.params_dict[x][0])
@@ -220,20 +220,20 @@ class SVICalibrator:
 
         # Update calendar arbitrage status
         for mat in sorted_maturities:
-            mat_name = maturity_name_dict[mat]
+            mat_name = maturity_dict[mat]
             fit_results.at[mat_name, 'calendar_arbitrage_free'] = calendar_arbitrage_free
 
         # Correct calendar arbitrage violations
-        self.correct_calendar_arbitrage(sorted_maturities, fit_results, maturity_name_dict)
+        self.correct_calendar_arbitrage(sorted_maturities, fit_results, maturity_dict)
 
         # Clean up results and report execution time
-        fit_results = fit_results.drop(columns='maturity_name')
+        fit_results = fit_results.drop(columns='maturity')
         end_time = time.time()
         logger.info(f"Total model execution time: {end_time - start_time:.4f} seconds")
 
         return fit_results
 
-    def correct_calendar_arbitrage(self, sorted_maturities, fit_results, maturity_name_dict):
+    def correct_calendar_arbitrage(self, sorted_maturities, fit_results, maturity_dict):
         """Handle calendar arbitrage corrections"""
         for i in range(1, len(sorted_maturities)):
             mat2 = sorted_maturities[i]
@@ -259,7 +259,7 @@ class SVICalibrator:
 
             # Calculate new stats and update results
             stats = self.calculate_model_stats(new_params, t2, k, iv)
-            mat2_name = maturity_name_dict[mat2]
+            mat2_name = maturity_dict[mat2]
 
             # Update all stats at once
             for key, value in stats.items():
@@ -273,7 +273,7 @@ class SVICalibrator:
 
         # Update final status
         for mat in sorted_maturities:
-            mat_name = maturity_name_dict[mat]
+            mat_name = maturity_dict[mat]
             fit_results.at[mat_name, 'calendar_arbitrage_free'] = calendar_arbitrage_free
 
 
@@ -287,7 +287,7 @@ def fit_model(option_chain: pd.DataFrame, num_points: int = 2000) -> pd.DataFram
     - num_points: Number of points for k_grid and plotting
 
     Returns:
-    - fit_results: DataFrame with all fit results and performance metrics as columns, maturity_names as index
+    - fit_results: DataFrame with all fit results and performance metrics as columns, maturities as index
     """
     currency = option_chain['currency'].iloc[0] if 'currency' in option_chain.columns else 'Unknown'
 

voly/core/interpolate.py

@@ -77,12 +77,12 @@ def interpolate_model(fit_results: pd.DataFrame,
 
     # Calculate maturity dates
     now = dt.datetime.now()
-    maturity_dates = []
+    expiries = []
     for days in target_days:
-        maturity_date = now + dt.timedelta(days=days)
-        maturity_dates.append(maturity_date)
+        expiry = now + dt.timedelta(days=days)
+        expiries.append(expiry)
 
-    interpolated_df['maturity_date'] = maturity_dates
+    interpolated_df['expiry'] = expiries
 
     # Sort fit_results by ytm
     sorted_fit_results = fit_results.iloc[sorted_indices]
@@ -118,7 +118,7 @@ def interpolate_model(fit_results: pd.DataFrame,
                 interpolated_df[param] = f(target_years)
 
     # Ensure consistent ordering of columns with expected structure
-    expected_columns = ['s', 't', 'r', 'maturity_date', 'a', 'b', 'm', 'rho', 'sigma',
+    expected_columns = ['s', 't', 'r', 'expiry', 'a', 'b', 'm', 'rho', 'sigma',
                         'nu', 'psi', 'p', 'c', 'nu_tilde']
 
     # Create final column order based on available columns

voly/formulas.py

@@ -18,7 +18,7 @@ def vectorize_inputs(func):
     For invalid inputs (K <= 0, o <= 0, or t <= 0), returns np.nan instead of trying to compute.
     """
 
-    def wrapper(s, K, r, o, t, option_type='call'):
+    def wrapper(s, K, r, o, t, flag='call'):
         # Check if inputs are scalar
         K_scalar = np.isscalar(K)
         o_scalar = np.isscalar(o)
@@ -34,7 +34,7 @@ def vectorize_inputs(func):
 
         # If all inputs are scalar, use the original function directly
         if K_scalar and o_scalar and t_scalar:
-            return func(s, K, r, o, t, option_type)
+            return func(s, K, r, o, t, flag)
 
         # For arrays, we need to apply the function element-wise
         # Instead of using np.vectorize directly, we'll create a custom vectorized function
@@ -45,7 +45,7 @@ def vectorize_inputs(func):
                 return np.nan  # Return NaN for invalid inputs
             else:
                 # Only call the function if inputs are valid
-                return func(s, K_val, r, o_val, t_val, option_type)
+                return func(s, K_val, r, o_val, t_val, flag)
 
         # Now use numpy's vectorize on our safe function
         vectorized_func = np.vectorize(safe_vectorized_func)
@@ -58,24 +58,24 @@ def vectorize_inputs(func):
 
 @catch_exception
 @vectorize_inputs
-def d1(s: float, K: float, r: float, o: float, t: float, option_type: str = 'call') -> float:
-    # option_type is ignored in this function but included for compatibility
+def d1(s: float, K: float, r: float, o: float, t: float, flag: str = 'call') -> float:
+    # flag is ignored in this function but included for compatibility
     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:
-    # option_type is ignored in this function but included for compatibility
-    return d1(s, K, r, o, t, option_type) - o * np.sqrt(t)
+def d2(s: float, K: float, r: float, o: float, t: float, flag: str = 'call') -> float:
+    # flag is ignored in this function but included for compatibility
+    return d1(s, K, r, o, t, flag) - o * np.sqrt(t)
 
 
 @catch_exception
 @vectorize_inputs
-def bs(s: float, K: float, r: float, o: float, t: float, option_type: str = 'call') -> float:
+def bs(s: float, K: float, r: float, o: float, t: float, flag: str = 'call') -> float:
     if o <= 0 or t <= 0:
         # Intrinsic value at expiry
-        if option_type.lower() in ["call", "c"]:
+        if flag.lower() in ["call", "c"]:
             return max(0, s - K)
         else:
             return max(0, K - s)
@@ -83,7 +83,7 @@ def bs(s: float, K: float, r: float, o: float, t: float, option_type: str = 'cal
     d1_val = d1(s, K, r, o, t)
     d2_val = d2(s, K, r, o, t)
 
-    if option_type.lower() in ["call", "c"]:
+    if flag.lower() in ["call", "c"]:
         return s * norm.cdf(d1_val) - K * np.exp(-r * t) * norm.cdf(d2_val)
     else:  # put
         return K * np.exp(-r * t) * norm.cdf(-d2_val) - s * norm.cdf(-d1_val)
@@ -91,17 +91,17 @@ def bs(s: float, K: float, r: float, o: float, t: float, option_type: str = 'cal
 
 @catch_exception
 @vectorize_inputs
-def delta(s: float, K: float, r: float, o: float, t: float, option_type: str = 'call') -> float:
+def delta(s: float, K: float, r: float, o: float, t: float, flag: str = 'call') -> float:
     if o <= 0 or t <= 0:
         # At expiry, delta is either 0 or 1 for call, 0 or -1 for put
-        if option_type.lower() in ["call", "c"]:
+        if flag.lower() in ["call", "c"]:
             return 1.0 if s > K else 0.0
         else:
             return -1.0 if s < K else 0.0
 
     d1_val = d1(s, K, r, o, t)
 
-    if option_type.lower() in ["call", "c"]:
+    if flag.lower() in ["call", "c"]:
         return norm.cdf(d1_val)
     else:  # put
         return norm.cdf(d1_val) - 1.0
@@ -109,29 +109,29 @@ def delta(s: float, K: float, r: float, o: float, t: float, option_type: str = '
 
 @catch_exception
 @vectorize_inputs
-def gamma(s: float, K: float, r: float, o: float, t: float, option_type: str = 'call') -> float:
-    d1_val = d1(s, K, r, o, t, option_type)
+def gamma(s: float, K: float, r: float, o: float, t: float, flag: str = 'call') -> float:
+    d1_val = d1(s, K, r, o, t, flag)
     return norm.pdf(d1_val) / (s * o * np.sqrt(t))
 
 
 @catch_exception
 @vectorize_inputs
-def vega(s: float, K: float, r: float, o: float, t: float, option_type: str = 'call') -> float:
-    d1_val = d1(s, K, r, o, t, option_type)
+def vega(s: float, K: float, r: float, o: float, t: float, flag: str = 'call') -> float:
+    d1_val = d1(s, K, r, o, t, flag)
     return s * norm.pdf(d1_val) * np.sqrt(t) / 100  # Divided by 100 for 1% change
 
 
 @catch_exception
 @vectorize_inputs
-def theta(s: float, K: float, r: float, o: float, t: float, option_type: str = 'call') -> float:
-    d1_val = d1(s, K, r, o, t, option_type)
-    d2_val = d2(s, K, r, o, t, option_type)
+def theta(s: float, K: float, r: float, o: float, t: float, flag: str = 'call') -> float:
+    d1_val = d1(s, K, r, o, t, flag)
+    d2_val = d2(s, K, r, o, t, flag)
 
     # First part of theta (same for both call and put)
     theta_part1 = -s * norm.pdf(d1_val) * o / (2 * np.sqrt(t))
 
     # Second part depends on option type
-    if option_type.lower() in ["call", "c"]:
+    if flag.lower() in ["call", "c"]:
         theta_part2 = -r * K * np.exp(-r * t) * norm.cdf(d2_val)
     else:  # put
         theta_part2 = r * K * np.exp(-r * t) * norm.cdf(-d2_val)
@@ -142,10 +142,10 @@ def theta(s: float, K: float, r: float, o: float, t: float, option_type: str = '
 
 @catch_exception
 @vectorize_inputs
-def rho(s: float, K: float, r: float, o: float, t: float, option_type: str = 'call') -> float:
-    d2_val = d2(s, K, r, o, t, option_type)
+def rho(s: float, K: float, r: float, o: float, t: float, flag: str = 'call') -> float:
+    d2_val = d2(s, K, r, o, t, flag)
 
-    if option_type.lower() in ["call", "c"]:
+    if flag.lower() in ["call", "c"]:
         return K * t * np.exp(-r * t) * norm.cdf(d2_val) / 100
     else:  # put
         return -K * t * np.exp(-r * t) * norm.cdf(-d2_val) / 100
@@ -153,33 +153,33 @@ def rho(s: float, K: float, r: float, o: float, t: float, option_type: str = 'ca
 
 @catch_exception
 @vectorize_inputs
-def vanna(s: float, K: float, r: float, o: float, t: float, option_type: str = 'call') -> float:
-    d1_val = d1(s, K, r, o, t, option_type)
-    d2_val = d2(s, K, r, o, t, option_type)
+def vanna(s: float, K: float, r: float, o: float, t: float, flag: str = 'call') -> float:
+    d1_val = d1(s, K, r, o, t, flag)
+    d2_val = d2(s, K, r, o, t, flag)
 
     return -norm.pdf(d1_val) * d2_val / o
 
 
 @catch_exception
 @vectorize_inputs
-def volga(s: float, K: float, r: float, o: float, t: float, option_type: str = 'call') -> float:
-    d1_val = d1(s, K, r, o, t, option_type)
-    d2_val = d2(s, K, r, o, t, option_type)
+def volga(s: float, K: float, r: float, o: float, t: float, flag: str = 'call') -> float:
+    d1_val = d1(s, K, r, o, t, flag)
+    d2_val = d2(s, K, r, o, t, flag)
 
     return s * norm.pdf(d1_val) * np.sqrt(t) * d1_val * d2_val / o
 
 
 @catch_exception
 @vectorize_inputs
-def charm(s: float, K: float, r: float, o: float, t: float, option_type: str = 'call') -> float:
-    d1_val = d1(s, K, r, o, t, option_type)
-    d2_val = d2(s, K, r, o, t, option_type)
+def charm(s: float, K: float, r: float, o: float, t: float, flag: str = 'call') -> float:
+    d1_val = d1(s, K, r, o, t, flag)
+    d2_val = d2(s, K, r, o, t, flag)
 
     # First term is the same for calls and puts
     term1 = -norm.pdf(d1_val) * d1_val / (2 * t)
 
     # Second term depends on option type
-    if option_type.lower() in ["call", "c"]:
+    if flag.lower() in ["call", "c"]:
         term2 = -r * np.exp(-r * t) * norm.cdf(d2_val)
     else:  # put
         term2 = r * np.exp(-r * t) * norm.cdf(-d2_val)
@@ -191,24 +191,24 @@ def charm(s: float, K: float, r: float, o: float, t: float, option_type: str = '
 @catch_exception
 @vectorize_inputs
 def greeks(s: float, K: float, r: float, o: float, t: float,
-           option_type: str = 'call') -> Dict[str, float]:
+           flag: str = 'call') -> Dict[str, float]:
     return {
-        'price': bs(s, K, r, o, t, option_type),
-        'delta': delta(s, K, r, o, t, option_type),
-        'gamma': gamma(s, K, r, o, t, option_type),
-        'vega': vega(s, K, r, o, t, option_type),
-        'theta': theta(s, K, r, o, t, option_type),
-        'rho': rho(s, K, r, o, t, option_type),
-        'vanna': vanna(s, K, r, o, t, option_type),
-        'volga': volga(s, K, r, o, t, option_type),
-        'charm': charm(s, K, r, o, t, option_type)
+        'price': bs(s, K, r, o, t, flag),
+        'delta': delta(s, K, r, o, t, flag),
+        'gamma': gamma(s, K, r, o, t, flag),
+        'vega': vega(s, K, r, o, t, flag),
+        'theta': theta(s, K, r, o, t, flag),
+        'rho': rho(s, K, r, o, t, flag),
+        'vanna': vanna(s, K, r, o, t, flag),
+        'volga': volga(s, K, r, o, t, flag),
+        'charm': charm(s, K, r, o, t, flag)
     }
 
 
 @catch_exception
 @vectorize_inputs
 def iv(option_price: float, s: float, K: float, r: float, t: float,
-       option_type: str = 'call') -> float:
+       flag: str = 'call') -> float:
     """
     Calculate implied volatility using py_volib for vectorized computation.
 
@@ -218,14 +218,14 @@ def iv(option_price: float, s: float, K: float, r: float, t: float,
     - K: Strike price
     - r: Risk-free rate
     - t: Time to expiry in years
-    - option_type: 'call' or 'put'
+    - flag: 'call' or 'put'
 
     Returns:
     - Implied volatility
     """
 
     # Check if option price is within theoretical bounds
-    if option_type.lower() in ["call", "c"]:
+    if flag.lower() in ["call", "c"]:
         intrinsic = max(0, s - K * np.exp(-r * t))
         if option_price < intrinsic:
             return np.nan  # Price below intrinsic value
@@ -238,7 +238,7 @@ def iv(option_price: float, s: float, K: float, r: float, t: float,
         if option_price >= K:
             return np.inf  # Price exceeds strike
 
-    flag = 'c' if option_type.lower() in ["call", "c"] else 'p'
+    flag = 'c' if flag.lower() in ["call", "c"] else 'p'
 
     iv_value = implied_volatility(
         price=option_price,

{voly-0.0.226.dist-info → voly-0.0.228.dist-info}/METADATA

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

voly-0.0.228.dist-info/RECORD

@@ -0,0 +1,20 @@
+voly/__init__.py,sha256=8xyDk7rFCn_MOD5hxuv5cxxKZvBVRiSIM7TgaMPpwpw,211
+voly/client.py,sha256=H4BY5n1isHOqMYX-Koe8-WKBKE6zxbdDYopDF58BPBI,14533
+voly/exceptions.py,sha256=PBsbn1vNMvKcCJwwJ4lBO6glD85jo1h2qiEmD7ArAjs,92
+voly/formulas.py,sha256=Jx2QSTkN3S_X1YWYXN3T0gBcxMKB_VLsqgDPg32ApmM,10833
+voly/models.py,sha256=CGJQr13Uie7iwtx2hjViN9lMXeRN_uOqzp4u8NPaTlA,9282
+voly/core/__init__.py,sha256=bu6fS2I1Pj9fPPnl-zY3L7NqrZSY5Zy6NY2uMUvdhKs,183
+voly/core/charts.py,sha256=6MSU0z01fPOVSssodxdnFqchzDfupSmXq_e71WwDmVQ,12635
+voly/core/data.py,sha256=4E-zF2wJwumbWcrGVOS59ebApRKnxyyUXCTTriUk45Y,12389
+voly/core/fit.py,sha256=R3aDgCjvZ30PujoE9pgnGQXPQOTTMbk7_-RQ0ZMx5ig,13918
+voly/core/hd.py,sha256=dSv197RmSWFWbRRdoBzMrD_poT7ZiJ8hdD_wKE-Li_M,13559
+voly/core/interpolate.py,sha256=GAkrqaar7A0D6UMipXQUp4vSHRfb44TmCG5Xiv9elXg,5176
+voly/core/rnd.py,sha256=wiZ5OIjPDf1Th5_sQ9CZG5JgAo3EL8f63T_Rj1_VP-0,13214
+voly/utils/__init__.py,sha256=E05mWatyC-PDOsCxQV1p5Xi1IgpOomxrNURyCx_gB-w,200
+voly/utils/density.py,sha256=ONpRli-IaJDgOZ2sb27HHFc9_tkkGSATKl94JODd86A,5879
+voly/utils/logger.py,sha256=4-_2bVJmq17Q0d7Rd2mPg1AeR8gxv6EPvcmBDMFWcSM,1744
+voly-0.0.228.dist-info/licenses/LICENSE,sha256=wcHIVbE12jfcBOai_wqBKY6xvNQU5E909xL1zZNq_2Q,1065
+voly-0.0.228.dist-info/METADATA,sha256=_21vNdPGISj2HC7IKCjC47LHjMq2F1qPbKOEF9oFbb0,4115
+voly-0.0.228.dist-info/WHEEL,sha256=ck4Vq1_RXyvS4Jt6SI0Vz6fyVs4GWg7AINwpsaGEgPE,91
+voly-0.0.228.dist-info/top_level.txt,sha256=ZfLw2sSxF-LrKAkgGjOmeTcw6_gD-30zvtdEY5W4B7c,5
+voly-0.0.228.dist-info/RECORD,,

voly-0.0.226.dist-info/RECORD

@@ -1,20 +0,0 @@
-voly/__init__.py,sha256=8xyDk7rFCn_MOD5hxuv5cxxKZvBVRiSIM7TgaMPpwpw,211
-voly/client.py,sha256=F5jRdmEfxoE2RGHryCntRFrKLlyS7W974jEtEcBz8Co,14410
-voly/exceptions.py,sha256=PBsbn1vNMvKcCJwwJ4lBO6glD85jo1h2qiEmD7ArAjs,92
-voly/formulas.py,sha256=Jn9hBoIx6PGv9k4lm8PeGM4lxFJkrLau8LpnXatdQPM,11176
-voly/models.py,sha256=CGJQr13Uie7iwtx2hjViN9lMXeRN_uOqzp4u8NPaTlA,9282
-voly/core/__init__.py,sha256=bu6fS2I1Pj9fPPnl-zY3L7NqrZSY5Zy6NY2uMUvdhKs,183
-voly/core/charts.py,sha256=2S-BfCo30aj1_xlNLqF-za5rQWxF_mWKIdtdOe5bgbw,12735
-voly/core/data.py,sha256=SNF87C7-r-1IbKwf7rAhXkJ6X305yo7fCDJDdkwz3NM,14103
-voly/core/fit.py,sha256=bVyx7qMgFFpTUjgoCUs58ppmeNN2CORnqPKbGUpV9xw,14081
-voly/core/hd.py,sha256=dSv197RmSWFWbRRdoBzMrD_poT7ZiJ8hdD_wKE-Li_M,13559
-voly/core/interpolate.py,sha256=-cNChFpuLnCSMOmfW2ldXxePgQXi-pxcjJvF2yImD1w,5222
-voly/core/rnd.py,sha256=wiZ5OIjPDf1Th5_sQ9CZG5JgAo3EL8f63T_Rj1_VP-0,13214
-voly/utils/__init__.py,sha256=E05mWatyC-PDOsCxQV1p5Xi1IgpOomxrNURyCx_gB-w,200
-voly/utils/density.py,sha256=ONpRli-IaJDgOZ2sb27HHFc9_tkkGSATKl94JODd86A,5879
-voly/utils/logger.py,sha256=4-_2bVJmq17Q0d7Rd2mPg1AeR8gxv6EPvcmBDMFWcSM,1744
-voly-0.0.226.dist-info/licenses/LICENSE,sha256=wcHIVbE12jfcBOai_wqBKY6xvNQU5E909xL1zZNq_2Q,1065
-voly-0.0.226.dist-info/METADATA,sha256=rLI85wsZs9RYkI2B-4-87qXHiKoarN-PEFrSfD6OdJE,4115
-voly-0.0.226.dist-info/WHEEL,sha256=ck4Vq1_RXyvS4Jt6SI0Vz6fyVs4GWg7AINwpsaGEgPE,91
-voly-0.0.226.dist-info/top_level.txt,sha256=ZfLw2sSxF-LrKAkgGjOmeTcw6_gD-30zvtdEY5W4B7c,5
-voly-0.0.226.dist-info/RECORD,,