voly 0.0.48__py3-none-any.whl → 0.0.51__py3-none-any.whl

voly/client.py

@@ -148,7 +148,8 @@ class VolyClient:
         return delta(s, k, r, vol, t, option_type)
 
     @staticmethod
-    def gamma(s: float, k: float, r: float, vol: float, t: float) -> float:
+    def gamma(s: float, k: float, r: float, vol: float, t: float,
+              option_type: str = 'call') -> float:
         """
         Calculate option gamma.
 
@@ -162,10 +163,11 @@ class VolyClient:
         Returns:
         - Gamma value
         """
-        return gamma(s, k, r, vol, t)
+        return gamma(s, k, r, vol, t, option_type)
 
     @staticmethod
-    def vega(s: float, k: float, r: float, vol: float, t: float) -> float:
+    def vega(s: float, k: float, r: float, vol: float, t: float,
+             option_type: str = 'call') -> float:
         """
         Calculate option vega.
 
@@ -179,7 +181,7 @@ class VolyClient:
         Returns:
         - Vega value (for 1% change in volatility)
         """
-        return vega(s, k, r, vol, t)
+        return vega(s, k, r, vol, t, option_type)
 
     @staticmethod
     def theta(s: float, k: float, r: float, vol: float, t: float,
@@ -220,7 +222,8 @@ class VolyClient:
         return rho(s, k, r, vol, t, option_type)
 
     @staticmethod
-    def vanna(s: float, k: float, r: float, vol: float, t: float) -> float:
+    def vanna(s: float, k: float, r: float, vol: float, t: float,
+              option_type: str = 'call') -> float:
         """
         Calculate option vanna.
 
@@ -234,10 +237,11 @@ class VolyClient:
         Returns:
         - Vanna value
         """
-        return vanna(s, k, r, vol, t)
+        return vanna(s, k, r, vol, t, option_type)
 
     @staticmethod
-    def volga(s: float, k: float, r: float, vol: float, t: float) -> float:
+    def volga(s: float, k: float, r: float, vol: float, t: float,
+              option_type: str = 'call') -> float:
         """
         Calculate option volga (vomma).
 
@@ -251,7 +255,7 @@ class VolyClient:
         Returns:
         - Volga value
         """
-        return volga(s, k, r, vol, t)
+        return volga(s, k, r, vol, t, option_type)
 
     @staticmethod
     def charm(s: float, k: float, r: float, vol: float, t: float,

voly/core/data.py

@@ -12,7 +12,7 @@ import json
 import pandas as pd
 import requests
 import time
-import datetime
+from datetime import datetime, timezone
 import re
 import numpy as np
 from typing import List, Dict, Any, Optional, Union
@@ -183,62 +183,39 @@ async def get_deribit_data(currency: str = "BTC") -> pd.DataFrame:
 
 
 @catch_exception
-def process_option_chain(df: pd.DataFrame, currency: str, min_dte: float = 2.0) -> pd.DataFrame:
+def process_option_chain(df: pd.DataFrame, currency: str) -> pd.DataFrame:
     """
     Process raw option chain data into a standardized format.
 
     Parameters:
     df (pd.DataFrame): Raw option chain data
     currency (str): Currency code (e.g., 'BTC', 'ETH')
-    min_dte (float): Minimum days to expiry to include
 
     Returns:
     pd.DataFrame: Processed option chain data
     """
     logger.info(f"Processing data for {currency}...")
 
-    # Extract instrument details
-    # Format is typically BTC-DDMMMYY-STRIKE-C/P or ETH-DDMMMYY-STRIKE-C/P
-    def extract_details(instrument_name):
-        pattern = f"{currency}-([\\d]{{1,2}})([A-Z]{{3}})(\\d{{2}})-([\\d]+)-([CP])"
-        match = re.match(pattern, instrument_name)
-        if match:
-            day = int(match.group(1))
-            month_str = match.group(2)
-            year = 2000 + int(match.group(3))
-            strike = float(match.group(4))
-            option_type = match.group(5)
-
-            month_dict = {'JAN': 1, 'FEB': 2, 'MAR': 3, 'APR': 4, 'MAY': 5, 'JUN': 6,
-                          'JUL': 7, 'AUG': 8, 'SEP': 9, 'OCT': 10, 'NOV': 11, 'DEC': 12}
-            month = month_dict.get(month_str)
-
-            maturity_name = f"{day}{month_str}{str(year)[-2:]}"
-
-            return {'day': day, 'month': month, 'year': year,
-                    'strike': strike, 'option_type': option_type,
-                    'maturity_name': maturity_name}
-        return None
-
     # Apply extraction to create new columns
-    df['details'] = df['instrument_name'].apply(lambda x: extract_details(x))
-    df['strike'] = df['details'].apply(lambda x: x['strike'] if x else None)
-    df['option_type'] = df['details'].apply(lambda x: x['option_type'] if x else None)
-    df['maturity_name'] = df['details'].apply(lambda x: x['maturity_name'] if x else None)
+    df['currency'] = df['instrument_name'].split('-')[0]
+    df['maturity_name'] = df['instrument_name'].split('-')[1]
+    df['strike'] = df['instrument_name'].split('-')[2]
+    df['option_type'] = df['instrument_name'].split('-')[3]
 
-    # Create expiry date at 8:00 AM UTC
-    df['expiry_date'] = df['details'].apply(
-        lambda x: datetime.datetime(x['year'], x['month'], x['day'], 8, 0, 0) if x else None
-    )
+    # Create maturity date at 8:00 AM UTC
+    df['maturity_date'] = pd.to_datetime(df['maturity_name'].apply(
+        lambda x: int(datetime.strptime(x, "%d%b%y")
+                      .replace(hour=8, minute=0, second=0, tzinfo=timezone.utc)
+                      .timestamp() * 1000)), unit='ms')
 
     # Get reference time from timestamp
     reference_time = datetime.datetime.fromtimestamp(df['timestamp'].iloc[0] / 1000)
 
     # Calculate days to expiry (DTE)
-    df['dte'] = (df['expiry_date'] - reference_time).dt.total_seconds() / (24 * 60 * 60)
+    df['dtm'] = (df['maturity_date'] - reference_time).dt.total_seconds() / (24 * 60 * 60)
 
     # Calculate time to expiry in years
-    df['yte'] = df['dte'] / 365.25
+    df['ytm'] = df['dtm'] / 365.25
 
     # Calculate implied volatility (convert from percentage)
     df['mark_iv'] = df['mark_iv'] / 100

voly/core/fit.py

@@ -20,7 +20,7 @@ warnings.filterwarnings("ignore")
 
 @catch_exception
 def calculate_residuals(params: List[float],
-                        time_to_expiry: float,
+                        ytm: float,
                         market_data: pd.DataFrame,
                         model: Any = SVIModel) -> np.ndarray:
     """
@@ -28,7 +28,7 @@ def calculate_residuals(params: List[float],
 
     Parameters:
     - params: Model parameters (e.g., SVI parameters [a, b, sigma, rho, m])
-    - time_to_expiry: The time to expiry in years
+    - ytm: The time to maturity in years
     - market_data: DataFrame with market data
     - model: Model class to use (default: SVIModel)
 
@@ -36,16 +36,16 @@ def calculate_residuals(params: List[float],
     - Array of residuals
     """
     # Filter market data for the specific time to expiry
-    specific_expiry_data = market_data[market_data['yte'] == time_to_expiry]
+    maturity_data = market_data[market_data['ytm'] == ytm]
 
-    # Calculate the total implied variance using the model for filtered data
-    w_model = np.array([model.svi(x, *params) for x in specific_expiry_data['log_moneyness']])
+    # Calculate the total implied variance (w) using the model for filtered data
+    w = np.array([model.svi(x, *params) for x in maturity_data['log_moneyness']])
 
     # Extract the actual market implied volatilities
-    iv_actual = specific_expiry_data['mark_iv'].values
+    iv_actual = maturity_data['mark_iv'].values
 
     # Calculate residuals between market implied volatilities and model predictions
-    residuals = iv_actual - np.sqrt(w_model / time_to_expiry)
+    residuals = iv_actual - np.sqrt(w / ytm)
 
     return residuals
 
@@ -74,17 +74,17 @@ def fit_svi_parameters(market_data: pd.DataFrame,
 
     # Initialize data for fit performance
     fit_data = {
-        'Maturity': [],
-        'DTE': [],
-        'YTE': [],
-        'Success': [],
-        'Cost': [],
-        'Optimality': [],
-        'RMSE': [],
-        'MAE': [],
-        'R²': [],
-        'Max Error': [],
-        'Number of Points': []
+        'maturity_name': [],
+        'dtm': [],
+        'ytm': [],
+        'fit_success': [],
+        'cost': [],
+        'optimality': [],
+        'rmse': [],
+        'mae': [],
+        'r2': [],
+        'max_error': [],
+        'n_point': []
     }
 
     # Dictionary to store parameters
@@ -96,13 +96,13 @@ def fit_svi_parameters(market_data: pd.DataFrame,
     RESET = '\033[0m'
 
     # Get unique expiries
-    unique_expiries = sorted(market_data['yte'].unique())
+    unique_maturities = sorted(market_data['ytm'].unique())
 
-    for yte in unique_expiries:
+    for ytm in unique_maturities:
         # Get maturity name for reporting
-        expiry_data = market_data[market_data['yte'] == yte]
-        maturity_name = expiry_data['maturity_name'].iloc[0]
-        dte_value = expiry_data['dte'].iloc[0]
+        maturity_data = market_data[market_data['ytm'] == ytm]
+        maturity_name = maturity_data['maturity_name'].iloc[0]
+        dtm = maturity_data['dtm'].iloc[0]
 
         logger.info(f"Optimizing for {maturity_name}...")
 
@@ -111,7 +111,7 @@ def fit_svi_parameters(market_data: pd.DataFrame,
             result = least_squares(
                 calculate_residuals,
                 initial_params,
-                args=(yte, market_data, SVIModel),
+                args=(ytm, market_data, SVIModel),
                 bounds=param_bounds,
                 max_nfev=1000
             )
@@ -122,14 +122,14 @@ def fit_svi_parameters(market_data: pd.DataFrame,
         params = result.x
         params_dict[maturity_name] = {
             'params': params,
-            'dte': dte_value,
-            'yte': yte
+            'dtm': dtm,
+            'ytm': ytm
         }
 
         # 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
+        w = np.array([SVIModel.svi(x, *params) for x in maturity_data['log_moneyness']])
+        iv_model = np.sqrt(w / ytm)
+        iv_market = maturity_data['mark_iv'].values
 
         # Calculate statistics
         rmse = np.sqrt(mean_squared_error(iv_market, iv_model))
@@ -139,17 +139,17 @@ def fit_svi_parameters(market_data: pd.DataFrame,
         num_points = len(expiry_data)
 
         # Add to fit data
-        fit_data['Maturity'].append(maturity_name)
-        fit_data['DTE'].append(dte_value)
-        fit_data['YTE'].append(yte)
-        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)
+        fit_data['maturity'].append(maturity_name)
+        fit_data['dtm'].append(dtm)
+        fit_data['ytm'].append(ytm)
+        fit_data['fit_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['r2'].append(r2)
+        fit_data['max_error'].append(max_error)
+        fit_data['n_points'].append(num_points)
 
         if result.success:
             logger.info(f'Optimization for {maturity_name}: {GREEN}SUCCESS{RESET}')
@@ -171,7 +171,7 @@ def create_parameters_matrix(params_dict: Dict[str, Dict]) -> Tuple[pd.DataFrame
     Uses maturity names as column names.
 
     Parameters:
-    - params_dict: Dictionary of parameter results by maturity name
+    - params_dict: Dictionary of raw parameter results by maturity name
 
     Returns:
     - Tuple of DataFrames with optimized parameters:
@@ -180,23 +180,23 @@ def create_parameters_matrix(params_dict: Dict[str, Dict]) -> Tuple[pd.DataFrame
     """
     # Get maturity names in order by DTE
     maturity_names = sorted(params_dict.keys(),
-                            key=lambda x: params_dict[x]['dte'])
+                            key=lambda x: params_dict[x]['dtm'])
 
-    # Create DataFrame for raw parameters with maturity names as columns
-    raw_param_matrix = pd.DataFrame(
+    # Create DataFrame for raw parameters
+    raw_params_matrix = pd.DataFrame(
         columns=maturity_names,
         index=SVIModel.PARAM_NAMES
     )
 
     # Create DataFrame for JW parameters
-    jw_param_matrix = pd.DataFrame(
+    jw_params_matrix = pd.DataFrame(
         columns=maturity_names,
         index=SVIModel.JW_PARAM_NAMES
     )
 
-    # Store YTE and DTE values for reference
-    yte_values = {}
-    dte_values = {}
+    # Store YTM and DTM values for reference
+    ytm_values = {}
+    dtm_values = {}
 
     # Fill the matrices with optimized parameters
     for maturity_name in maturity_names:
@@ -204,27 +204,27 @@ def create_parameters_matrix(params_dict: Dict[str, Dict]) -> Tuple[pd.DataFrame
 
         # Extract raw SVI parameters
         a, b, sigma, rho, m = result['params']
-        raw_param_matrix[maturity_name] = [a, b, sigma, rho, m]
+        raw_params_matrix[maturity_name] = [a, b, sigma, rho, m]
 
         # Get time to expiry
-        yte = result['yte']
-        yte_values[maturity_name] = yte
-        dte_values[maturity_name] = result['dte']
+        ytm = result['ytm']
+        ytm_values[maturity_name] = ytm
+        dtm_values[maturity_name] = result['dtm']
 
         # Calculate JW parameters
-        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]
+        nu, psi, p, c, nu_tilde = SVIModel.raw_to_jw_params(a, b, sigma, rho, m, ytm)
+        jw_params_matrix[maturity_name] = [nu, psi, p, c, nu_tilde]
 
     # Store YTE and DTE as attributes in all DataFrames for reference
     attrs = {
-        'yte_values': yte_values,
-        'dte_values': dte_values
+        'ytm_values': ytm_values,
+        'dtm_values': dtm_values
     }
 
-    raw_param_matrix.attrs.update(attrs)
-    jw_param_matrix.attrs.update(attrs)
+    raw_params_matrix.attrs.update(attrs)
+    jw_params_matrix.attrs.update(attrs)
 
-    return raw_param_matrix, jw_param_matrix
+    return raw_params_matrix, jw_params_matrix
 
 
 @catch_exception
@@ -255,46 +255,46 @@ def fit_model(market_data: pd.DataFrame,
     )
 
     # Step 2: Create parameter matrices
-    raw_param_matrix, jw_param_matrix = create_parameters_matrix(params_dict)
+    raw_params_matrix, jw_params_matrix = create_parameters_matrix(params_dict)
 
     return {
-        'raw_param_matrix': raw_param_matrix,
-        'jw_param_matrix': jw_param_matrix,
+        'raw_params_matrix': raw_params_matrix,
+        'jw_params_matrix': jw_params_matrix,
         'fit_performance': fit_performance,
     }
 
 
 @catch_exception
 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:
     - fit_results: results from fit_model()
-    - moneyness_params: Tuple of (min, max, num_points) for the moneyness grid
+    - log_moneyness_params: Tuple of (min, max, num_points) for the moneyness grid
 
     Returns:
-    - moneyness_array, iv_surface
+    - x_domain, iv_surface
     """
     iv_surface = {}
 
     # Extract moneyness parameters
-    min_m, max_m, num_points = moneyness_params
+    min_m, max_m, num_points = log_moneyness_params
 
-    # Generate moneyness grid
-    moneyness_array = np.linspace(min_m, max_m, num=num_points)
+    # Generate moneyness array
+    log_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']
-    maturity_values = fit_results['fit_performance']['Maturity']
-    param_matrix = fit_results['raw_param_matrix']
+    # Get YTM values from the parameter matrix attributes
+    ytm_values = fit_results['fit_performance']['ytm']
+    maturity_values = fit_results['fit_performance']['maturity_name']
+    raw_params_matrix = fit_results['raw_params_matrix']
 
     # 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_array]
-        iv_surface[maturity] = np.sqrt(np.array(w_svi) / yte)
+    for maturity, ytm in zip(maturity_values, ytm_values):
+        svi_params = raw_params_matrix[maturity].values
+        w_svi = [SVIModel.svi(x, *svi_params) for x in log_moneyness_array]
+        iv_surface[maturity] = np.sqrt(np.array(w_svi) / ytm)
 
     return moneyness_array, iv_surface

voly/formulas.py

@@ -90,21 +90,21 @@ def delta(s: float, k: float, r: float, vol: float, t: float, option_type: str =
 
 @catch_exception
 @vectorize_inputs
-def gamma(s: float, k: float, r: float, vol: float, t: float) -> float:
+def gamma(s: float, k: float, r: float, vol: float, t: float, option_type: str = 'call') -> float:
     if vol <= 0 or t <= 0:
         return 0.0
 
-    d1_val = d1(s, k, r, vol, t)
+    d1_val = d1(s, k, r, vol, t, option_type)
     return norm.pdf(d1_val) / (s * vol * np.sqrt(t))
 
 
 @catch_exception
 @vectorize_inputs
-def vega(s: float, k: float, r: float, vol: float, t: float) -> float:
+def vega(s: float, k: float, r: float, vol: float, t: float, option_type: str = 'call') -> float:
     if vol <= 0 or t <= 0:
         return 0.0
 
-    d1_val = d1(s, k, r, vol, t)
+    d1_val = d1(s, k, r, vol, t, option_type)
     return s * norm.pdf(d1_val) * np.sqrt(t) / 100  # Divided by 100 for 1% change
 
 
@@ -114,8 +114,8 @@ def theta(s: float, k: float, r: float, vol: float, t: float, option_type: str =
     if vol <= 0 or t <= 0:
         return 0.0
 
-    d1_val = d1(s, k, r, vol, t)
-    d2_val = d2(s, k, r, vol, t)
+    d1_val = d1(s, k, r, vol, t, option_type)
+    d2_val = d2(s, k, r, vol, t, option_type)
 
     # First part of theta (same for both call and put)
     theta_part1 = -s * norm.pdf(d1_val) * vol / (2 * np.sqrt(t))
@@ -136,7 +136,7 @@ def rho(s: float, k: float, r: float, vol: float, t: float, option_type: str = '
     if vol <= 0 or t <= 0:
         return 0.0
 
-    d2_val = d2(s, k, r, vol, t)
+    d2_val = d2(s, k, r, vol, t, option_type)
 
     if option_type.lower() in ["call", "c"]:
         return k * t * np.exp(-r * t) * norm.cdf(d2_val) / 100
@@ -146,24 +146,24 @@ def rho(s: float, k: float, r: float, vol: float, t: float, option_type: str = '
 
 @catch_exception
 @vectorize_inputs
-def vanna(s: float, k: float, r: float, vol: float, t: float) -> float:
+def vanna(s: float, k: float, r: float, vol: float, t: float, option_type: str = 'call') -> float:
     if vol <= 0 or t <= 0:
         return 0.0
 
-    d1_val = d1(s, k, r, vol, t)
-    d2_val = d2(s, k, r, vol, t)
+    d1_val = d1(s, k, r, vol, t, option_type)
+    d2_val = d2(s, k, r, vol, t, option_type)
 
     return -norm.pdf(d1_val) * d2_val / vol
 
 
 @catch_exception
 @vectorize_inputs
-def volga(s: float, k: float, r: float, vol: float, t: float) -> float:
+def volga(s: float, k: float, r: float, vol: float, t: float, option_type: str = 'call') -> float:
     if vol <= 0 or t <= 0:
         return 0.0
 
-    d1_val = d1(s, k, r, vol, t)
-    d2_val = d2(s, k, r, vol, t)
+    d1_val = d1(s, k, r, vol, t, option_type)
+    d2_val = d2(s, k, r, vol, t, option_type)
 
     return s * norm.pdf(d1_val) * np.sqrt(t) * d1_val * d2_val / vol
 
@@ -174,8 +174,8 @@ def charm(s: float, k: float, r: float, vol: float, t: float, option_type: str =
     if vol <= 0 or t <= 0:
         return 0.0
 
-    d1_val = d1(s, k, r, vol, t)
-    d2_val = d2(s, k, r, vol, t)
+    d1_val = d1(s, k, r, vol, t, option_type)
+    d2_val = d2(s, k, r, vol, t, option_type)
 
     # First term is the same for calls and puts
     term1 = -norm.pdf(d1_val) * d1_val / (2 * t)
@@ -187,7 +187,7 @@ def charm(s: float, k: float, r: float, vol: float, t: float, option_type: str =
         term2 = r * np.exp(-r * t) * norm.cdf(-d2_val)
 
     # Return charm per day (t is in years)
-    return (term1 + term2) / 365.0
+    return (term1 + term2) / 365.25
 
 
 @catch_exception
@@ -197,12 +197,12 @@ def greeks(s: float, k: float, r: float, vol: float, t: float,
     return {
         'price': bs(s, k, r, vol, t, option_type),
         'delta': delta(s, k, r, vol, t, option_type),
-        'gamma': gamma(s, k, r, vol, t),
-        'vega': vega(s, k, r, vol, t),
+        'gamma': gamma(s, k, r, vol, t, option_type),
+        'vega': vega(s, k, r, vol, t, option_type),
         'theta': theta(s, k, r, vol, t, option_type),
         'rho': rho(s, k, r, vol, t, option_type),
-        'vanna': vanna(s, k, r, vol, t),
-        'volga': volga(s, k, r, vol, t),
+        'vanna': vanna(s, k, r, vol, t, option_type),
+        'volga': volga(s, k, r, vol, t, option_type),
         'charm': charm(s, k, r, vol, t, option_type)
     }
 

voly/models.py

@@ -67,11 +67,11 @@ class SVIModel:
         return nu, psi, p, c, nu_tilde
 
     @staticmethod
-    def jw_to_raw_params(nu: float, phi: float, p: float, c: float, nu_tilde: float, t: float) -> Tuple[float, float, float, float, float]:
+    def jw_to_raw_params(nu: float, psi: float, p: float, c: float, nu_tilde: float, t: float) -> Tuple[float, float, float, float, float]:
         w = nu * t
         b = (c + p) / 2
         rho = (c - p) / (c + p)
-        beta = rho - ((2 * w * phi) / b)
+        beta = rho - ((2 * w * psi) / b)
         alpha = np.sign(beta) * (np.sqrt((1 / (beta ** 2)) - 1))
         m = (((nu ** 2) - (nu_tilde ** 2)) * t) / (
                 b * ((-rho) + (np.sign(alpha) * np.sqrt(1 + alpha ** 2)) - (alpha * np.sqrt(1 - rho ** 2))))

{voly-0.0.48.dist-info → voly-0.0.51.dist-info}/METADATA

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

{voly-0.0.48.dist-info → voly-0.0.51.dist-info}/RECORD

@@ -1,18 +1,18 @@
 voly/__init__.py,sha256=8xyDk7rFCn_MOD5hxuv5cxxKZvBVRiSIM7TgaMPpwpw,211
-voly/client.py,sha256=qkNC9CAuO6XRW9NYFNVJCead04Nntly7acU4O7TDO1o,20135
+voly/client.py,sha256=zOYgZA0TTJ5bHDCBWqEyeaQ0IKuee1uAIbzk0uyW_Uw,20350
 voly/exceptions.py,sha256=PBsbn1vNMvKcCJwwJ4lBO6glD85jo1h2qiEmD7ArAjs,92
-voly/formulas.py,sha256=XA8E19pKQtMWNUB6qB04laifsok9E0Wt7HVq4wNM6QE,8539
-voly/models.py,sha256=V2VI9yK-JyfKtI4nT5i42LQSwyGvexiymNiC2V1mQn4,3659
+voly/formulas.py,sha256=Xgaq4lx1fNzRfu9W84fMNeH6GRJ0FNFNUUUYn5ffjjE,8843
+voly/models.py,sha256=LXXIlpXZQEfXTuCngxC8Hd3bWtw6wdXDCSGxTLmHM-c,3659
 voly/core/__init__.py,sha256=bu6fS2I1Pj9fPPnl-zY3L7NqrZSY5Zy6NY2uMUvdhKs,183
 voly/core/charts.py,sha256=T8cogkiHj8NcFxfARumNvAjLJUAxsMlHUOVgshwjye8,26474
-voly/core/data.py,sha256=Dfk-ByHpdteUiLXr0p-wRLr3VAmdyjdDBKwjwdTgCjA,9939
-voly/core/fit.py,sha256=O4PMihVWI1NIEFU4_RkKvT73p0Jk0tB-ot5moMXAW78,9950
+voly/core/data.py,sha256=gEtmsp-cgCSdAWhnCrOHjrjUTfGJ_1NWkIEeHAkNkAg,8904
+voly/core/fit.py,sha256=PCKedwjY2Xsl_Gv9t46dAnEnFbz0T1oJsZsb__GWCSw,9878
 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.48.dist-info/LICENSE,sha256=wcHIVbE12jfcBOai_wqBKY6xvNQU5E909xL1zZNq_2Q,1065
-voly-0.0.48.dist-info/METADATA,sha256=wh8I_veTd38_APRaWlz82K0g257Ax2HQfNZjprlEIIw,4092
-voly-0.0.48.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
-voly-0.0.48.dist-info/top_level.txt,sha256=ZfLw2sSxF-LrKAkgGjOmeTcw6_gD-30zvtdEY5W4B7c,5
-voly-0.0.48.dist-info/RECORD,,
+voly-0.0.51.dist-info/LICENSE,sha256=wcHIVbE12jfcBOai_wqBKY6xvNQU5E909xL1zZNq_2Q,1065
+voly-0.0.51.dist-info/METADATA,sha256=FCA6dznopdWOB3Yt7cwscidzTclrUT4og6kHq3F5xUY,4092
+voly-0.0.51.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
+voly-0.0.51.dist-info/top_level.txt,sha256=ZfLw2sSxF-LrKAkgGjOmeTcw6_gD-30zvtdEY5W4B7c,5
+voly-0.0.51.dist-info/RECORD,,