voly 0.0.95__tar.gz → 0.0.97__tar.gz

{voly-0.0.95/src/voly.egg-info → voly-0.0.97}/PKG-INFO

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

{voly-0.0.95 → voly-0.0.97}/pyproject.toml

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

{voly-0.0.95 → voly-0.0.97}/src/voly/client.py

@@ -87,231 +87,69 @@ class VolyClient:
     # -------------------------------------------------------------------------
 
     @staticmethod
-    def svi(log_moneyness_array: float, a: float, b: float, sigma: float, rho: float, m: float) -> float:
-        return SVIModel.svi(log_moneyness_array, a, b, sigma, rho, m)
-
-    @staticmethod
-    def svi_d(log_moneyness_array: float, a: float, b: float, sigma: float, rho: float, m: float) -> float:
-        return SVIModel.svi_d(log_moneyness_array, a, b, sigma, rho, m)
-
-    @staticmethod
-    def svi_dd(log_moneyness_array: float, a: float, b: float, sigma: float, rho: float, m: float) -> float:
-        return SVIModel.svi_dd(log_moneyness_array, a, b, sigma, rho, m)
-
-    @staticmethod
-    def d1(s: float, k: float, r: float, vol: float, t: float,
+    def d1(s: float, K: float, r: float, o: float, t: float,
            option_type: str = 'call') -> float:
-        return d1(s, k, r, vol, t, option_type)
+        return d1(s, K, r, o, t, option_type)
 
     @staticmethod
-    def d2(s: float, k: float, r: float, vol: float, t: float,
+    def d2(s: float, K: float, r: float, o: float, t: float,
            option_type: str = 'call') -> float:
-        return d2(s, k, r, vol, t, option_type)
+        return d2(s, K, r, o, t, option_type)
 
     @staticmethod
-    def bs(s: float, k: float, r: float, vol: float, t: float,
+    def bs(s: float, K: float, r: float, o: float, t: float,
            option_type: str = 'call') -> float:
-        """
-        Calculate Black-Scholes option price.
-
-        Parameters:
-        - s: Underlying price
-        - k: Strike price
-        - r: Risk-free rate
-        - vol: Volatility
-        - t: Time to expiry in years
-        - option_type: 'call' or 'put'
-
-        Returns:
-        - Option price
-        """
-        return bs(s, k, r, vol, t, option_type)
+        return bs(s, K, r, o, t, option_type)
 
     @staticmethod
-    def delta(s: float, k: float, r: float, vol: float, t: float,
+    def delta(s: float, K: float, r: float, o: float, t: float,
               option_type: str = 'call') -> float:
-        """
-        Calculate option delta.
-
-        Parameters:
-        - s: Underlying price
-        - k: Strike price
-        - r: Risk-free rate
-        - vol: Volatility
-        - t: Time to expiry in years
-        - option_type: 'call' or 'put'
-
-        Returns:
-        - Delta value
-        """
-        return delta(s, k, r, vol, t, option_type)
+        return delta(s, K, r, o, t, option_type)
 
     @staticmethod
-    def gamma(s: float, k: float, r: float, vol: float, t: float,
+    def gamma(s: float, K: float, r: float, o: float, t: float,
               option_type: str = 'call') -> float:
-        """
-        Calculate option gamma.
-
-        Parameters:
-        - s: Underlying price
-        - k: Strike price
-        - r: Risk-free rate
-        - vol: Volatility
-        - t: Time to expiry in years
-
-        Returns:
-        - Gamma value
-        """
-        return gamma(s, k, r, vol, t, option_type)
+        return gamma(s, K, r, o, t, option_type)
 
     @staticmethod
-    def vega(s: float, k: float, r: float, vol: float, t: float,
+    def vega(s: float, K: float, r: float, o: float, t: float,
              option_type: str = 'call') -> float:
-        """
-        Calculate option vega.
-
-        Parameters:
-        - s: Underlying price
-        - k: Strike price
-        - r: Risk-free rate
-        - vol: Volatility
-        - t: Time to expiry in years
-
-        Returns:
-        - Vega value (for 1% change in volatility)
-        """
-        return vega(s, k, r, vol, t, option_type)
+        return vega(s, K, r, o, t, option_type)
 
     @staticmethod
-    def theta(s: float, k: float, r: float, vol: float, t: float,
+    def theta(s: float, K: float, r: float, o: float, t: float,
               option_type: str = 'call') -> float:
-        """
-        Calculate option theta.
-
-        Parameters:
-        - s: Underlying price
-        - k: Strike price
-        - r: Risk-free rate
-        - vol: Volatility
-        - t: Time to expiry in years
-        - option_type: 'call' or 'put'
-
-        Returns:
-        - Theta value (per day)
-        """
-        return theta(s, k, r, vol, t, option_type)
+        return theta(s, K, r, o, t, option_type)
 
     @staticmethod
-    def rho(s: float, k: float, r: float, vol: float, t: float,
+    def rho(s: float, K: float, r: float, o: float, t: float,
             option_type: str = 'call') -> float:
-        """
-        Calculate option rho.
-
-        Parameters:
-        - s: Underlying price
-        - k: Strike price
-        - r: Risk-free rate
-        - vol: Volatility
-        - t: Time to expiry in years
-        - option_type: 'call' or 'put'
-
-        Returns:
-        - Rho value (for 1% change in interest rate)
-        """
-        return rho(s, k, r, vol, t, option_type)
+        return rho(s, K, r, o, t, option_type)
 
     @staticmethod
-    def vanna(s: float, k: float, r: float, vol: float, t: float,
+    def vanna(s: float, K: float, r: float, o: float, t: float,
               option_type: str = 'call') -> float:
-        """
-        Calculate option vanna.
-
-        Parameters:
-        - s: Underlying price
-        - k: Strike price
-        - r: Risk-free rate
-        - vol: Volatility
-        - t: Time to expiry in years
-
-        Returns:
-        - Vanna value
-        """
-        return vanna(s, k, r, vol, t, option_type)
+        return vanna(s, K, r, o, t, option_type)
 
     @staticmethod
-    def volga(s: float, k: float, r: float, vol: float, t: float,
+    def volga(s: float, K: float, r: float, o: float, t: float,
               option_type: str = 'call') -> float:
-        """
-        Calculate option volga (vomma).
-
-        Parameters:
-        - s: Underlying price
-        - k: Strike price
-        - r: Risk-free rate
-        - vol: Volatility
-        - t: Time to expiry in years
-
-        Returns:
-        - Volga value
-        """
-        return volga(s, k, r, vol, t, option_type)
+        return volga(s, K, r, o, t, option_type)
 
     @staticmethod
-    def charm(s: float, k: float, r: float, vol: float, t: float,
+    def charm(s: float, K: float, r: float, o: float, t: float,
               option_type: str = 'call') -> float:
-        """
-        Calculate option charm (delta decay).
-
-        Parameters:
-        - s: Underlying price
-        - k: Strike price
-        - r: Risk-free rate
-        - vol: Volatility
-        - t: Time to expiry in years
-        - option_type: 'call' or 'put'
-
-        Returns:
-        - Charm value (per day)
-        """
-        return charm(s, k, r, vol, t, option_type)
+        return charm(s, K, r, o, t, option_type)
 
     @staticmethod
-    def greeks(s: float, k: float, r: float, vol: float, t: float,
+    def greeks(s: float, K: float, r: float, o: float, t: float,
                option_type: str = 'call') -> Dict[str, float]:
-        """
-        Calculate all option Greeks.
-
-        Parameters:
-        - s: Underlying price
-        - k: Strike price
-        - r: Risk-free rate
-        - vol: Volatility
-        - t: Time to expiry in years
-        - option_type: 'call' or 'put'
-
-        Returns:
-        - Dictionary with all Greeks (price, delta, gamma, vega, theta, rho, vanna, volga, charm)
-        """
-        return greeks(s, k, r, vol, t, option_type)
+        return greeks(s, K, r, o, t, option_type)
 
     @staticmethod
-    def iv(option_price: float, s: float, k: float, r: float, t: float,
+    def iv(option_price: float, s: float, K: float, r: float, t: float,
            option_type: str = 'call') -> float:
-        """
-        Calculate implied volatility.
-
-        Parameters:
-        - option_price: Market price of the option
-        - s: Underlying price
-        - k: Strike price
-        - r: Risk-free rate
-        - t: Time to expiry in years
-        - option_type: 'call' or 'put'
-
-        Returns:
-        - Implied volatility
-        """
-        return iv(option_price, s, k, r, t, option_type)
+        return iv(option_price, s, K, r, t, option_type)
 
     # -------------------------------------------------------------------------
     # Model Fitting

{voly-0.0.95 → voly-0.0.97}/src/voly/formulas.py

@@ -15,72 +15,72 @@ def vectorize_inputs(func):
     """
     Decorator to vectorize Black-Scholes functions to handle both scalar and array inputs.
     """
-    def wrapper(s, k, r, vol, t, option_type='call'):
+    def wrapper(s, K, r, o, t, option_type='call'):
         # Check if inputs are scalar
-        k_scalar = np.isscalar(k)
-        vol_scalar = np.isscalar(vol)
+        K_scalar = np.isscalar(K)
+        o_scalar = np.isscalar(o)
 
         # If both inputs are scalar, use the original function directly
-        if k_scalar and vol_scalar:
-            return func(s, k, r, vol, t, option_type)
+        if K_scalar and o_scalar:
+            return func(s, K, r, o, t, option_type)
 
         # Use NumPy's vectorize to handle array inputs
-        vectorized_func = np.vectorize(lambda k_val, vol_val:
-                                       func(s, k_val, r, vol_val, t, option_type))
+        vectorized_func = np.vectorize(lambda K_val, o_val:
+                                       func(s, K_val, r, o_val, t, option_type))
 
         # Call the vectorized function with the inputs
-        return vectorized_func(k, vol)
+        return vectorized_func(K, o)
 
     return wrapper
 
 
 @catch_exception
 @vectorize_inputs
-def d1(s: float, k: float, r: float, vol: float, t: float, option_type: str = 'call') -> float:
+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
-    if vol <= 0 or t <= 0:
+    if o <= 0 or t <= 0:
         return np.nan
-    return (np.log(s / k) + (r + vol ** 2 / 2) * t) / (vol * np.sqrt(t))
+    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, vol: float, t: float, option_type: str = 'call') -> float:
+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
-    if vol <= 0 or t <= 0:
+    if o <= 0 or t <= 0:
         return np.nan
-    return d1(s, k, r, vol, t, option_type) - vol * np.sqrt(t)
+    return d1(s, K, r, o, t, option_type) - o * np.sqrt(t)
 
 
 @catch_exception
 @vectorize_inputs
-def bs(s: float, k: float, r: float, vol: float, t: float, option_type: str = 'call') -> float:
-    if vol <= 0 or t <= 0:
+def bs(s: float, K: float, r: float, o: float, t: float, option_type: str = 'call') -> float:
+    if o <= 0 or t <= 0:
         # Intrinsic value at expiry
         if option_type.lower() in ["call", "c"]:
-            return max(0, s - k)
+            return max(0, s - K)
         else:
-            return max(0, k - s)
+            return max(0, K - s)
 
-    d1_val = d1(s, k, r, vol, t)
-    d2_val = d2(s, k, r, vol, t)
+    d1_val = d1(s, K, r, o, t)
+    d2_val = d2(s, K, r, o, t)
 
     if option_type.lower() in ["call", "c"]:
-        return s * norm.cdf(d1_val) - k * np.exp(-r * t) * norm.cdf(d2_val)
+        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)
+        return K * np.exp(-r * t) * norm.cdf(-d2_val) - s * norm.cdf(-d1_val)
 
 
 @catch_exception
 @vectorize_inputs
-def delta(s: float, k: float, r: float, vol: float, t: float, option_type: str = 'call') -> float:
-    if vol <= 0 or t <= 0:
+def delta(s: float, K: float, r: float, o: float, t: float, option_type: 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"]:
-            return 1.0 if s > k else 0.0
+            return 1.0 if s > K else 0.0
         else:
-            return -1.0 if s < k else 0.0
+            return -1.0 if s < K else 0.0
 
-    d1_val = d1(s, k, r, vol, t)
+    d1_val = d1(s, K, r, o, t)
 
     if option_type.lower() in ["call", "c"]:
         return norm.cdf(d1_val)
@@ -90,41 +90,41 @@ 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, option_type: str = 'call') -> float:
-    if vol <= 0 or t <= 0:
+def gamma(s: float, K: float, r: float, o: float, t: float, option_type: str = 'call') -> float:
+    if o <= 0 or t <= 0:
         return 0.0
 
-    d1_val = d1(s, k, r, vol, t, option_type)
-    return norm.pdf(d1_val) / (s * vol * np.sqrt(t))
+    d1_val = d1(s, K, r, o, t, option_type)
+    return norm.pdf(d1_val) / (s * o * np.sqrt(t))
 
 
 @catch_exception
 @vectorize_inputs
-def vega(s: float, k: float, r: float, vol: float, t: float, option_type: str = 'call') -> float:
-    if vol <= 0 or t <= 0:
+def vega(s: float, K: float, r: float, o: float, t: float, option_type: str = 'call') -> float:
+    if o <= 0 or t <= 0:
         return 0.0
 
-    d1_val = d1(s, k, r, vol, t, option_type)
+    d1_val = d1(s, K, r, o, t, option_type)
     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, vol: float, t: float, option_type: str = 'call') -> float:
-    if vol <= 0 or t <= 0:
+def theta(s: float, K: float, r: float, o: float, t: float, option_type: str = 'call') -> float:
+    if o <= 0 or t <= 0:
         return 0.0
 
-    d1_val = d1(s, k, r, vol, t, option_type)
-    d2_val = d2(s, k, r, vol, t, option_type)
+    d1_val = d1(s, K, r, o, t, option_type)
+    d2_val = d2(s, K, r, o, 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))
+    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"]:
-        theta_part2 = -r * k * np.exp(-r * t) * norm.cdf(d2_val)
+        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)
+        theta_part2 = r * K * np.exp(-r * t) * norm.cdf(-d2_val)
 
     # Return theta per day (t is in years)
     return (theta_part1 + theta_part2) / 365.0
@@ -132,50 +132,50 @@ def theta(s: float, k: float, r: float, vol: float, t: float, option_type: str =
 
 @catch_exception
 @vectorize_inputs
-def rho(s: float, k: float, r: float, vol: float, t: float, option_type: str = 'call') -> float:
-    if vol <= 0 or t <= 0:
+def rho(s: float, K: float, r: float, o: float, t: float, option_type: str = 'call') -> float:
+    if o <= 0 or t <= 0:
         return 0.0
 
-    d2_val = d2(s, k, r, vol, t, option_type)
+    d2_val = d2(s, K, r, o, t, option_type)
 
     if option_type.lower() in ["call", "c"]:
-        return k * t * np.exp(-r * t) * norm.cdf(d2_val) / 100
+        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
+        return -K * t * np.exp(-r * t) * norm.cdf(-d2_val) / 100
 
 
 @catch_exception
 @vectorize_inputs
-def vanna(s: float, k: float, r: float, vol: float, t: float, option_type: str = 'call') -> float:
-    if vol <= 0 or t <= 0:
+def vanna(s: float, K: float, r: float, o: float, t: float, option_type: str = 'call') -> float:
+    if o <= 0 or t <= 0:
         return 0.0
 
-    d1_val = d1(s, k, r, vol, t, option_type)
-    d2_val = d2(s, k, r, vol, t, option_type)
+    d1_val = d1(s, K, r, o, t, option_type)
+    d2_val = d2(s, K, r, o, t, option_type)
 
-    return -norm.pdf(d1_val) * d2_val / vol
+    return -norm.pdf(d1_val) * d2_val / o
 
 
 @catch_exception
 @vectorize_inputs
-def volga(s: float, k: float, r: float, vol: float, t: float, option_type: str = 'call') -> float:
-    if vol <= 0 or t <= 0:
+def volga(s: float, K: float, r: float, o: float, t: float, option_type: str = 'call') -> float:
+    if o <= 0 or t <= 0:
         return 0.0
 
-    d1_val = d1(s, k, r, vol, t, option_type)
-    d2_val = d2(s, k, r, vol, t, option_type)
+    d1_val = d1(s, K, r, o, t, option_type)
+    d2_val = d2(s, K, r, o, t, option_type)
 
-    return s * norm.pdf(d1_val) * np.sqrt(t) * d1_val * d2_val / vol
+    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, vol: float, t: float, option_type: str = 'call') -> float:
-    if vol <= 0 or t <= 0:
+def charm(s: float, K: float, r: float, o: float, t: float, option_type: str = 'call') -> float:
+    if o <= 0 or t <= 0:
         return 0.0
 
-    d1_val = d1(s, k, r, vol, t, option_type)
-    d2_val = d2(s, k, r, vol, t, option_type)
+    d1_val = d1(s, K, r, o, t, option_type)
+    d2_val = d2(s, K, r, o, t, option_type)
 
     # First term is the same for calls and puts
     term1 = -norm.pdf(d1_val) * d1_val / (2 * t)
@@ -192,34 +192,34 @@ def charm(s: float, k: float, r: float, vol: float, t: float, option_type: str =
 
 @catch_exception
 @vectorize_inputs
-def greeks(s: float, k: float, r: float, vol: float, t: float,
+def greeks(s: float, K: float, r: float, o: float, t: float,
            option_type: str = 'call') -> Dict[str, 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, 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, option_type),
-        'volga': volga(s, k, r, vol, t, option_type),
-        'charm': charm(s, k, r, vol, t, option_type)
+        '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)
     }
 
 
 @catch_exception
 @vectorize_inputs
-def iv(option_price: float, s: float, k: float, r: float, t: float,
+def iv(option_price: float, s: float, K: float, r: float, t: float,
        option_type: str = 'call', precision: float = 1e-8,
        max_iterations: int = 100) -> float:
     """
     Calculate implied volatility using Newton-Raphson method.
 
     Parameters:
-    - option_price: Market price of the option
+    - option_price: MarKet price of the option
     - s: Underlying price
-    - k: Strike price
-    - r: Risk-free rate
+    - K: Strike price
+    - r: RisK-free rate
     - t: Time to expiry in years
     - option_type: 'call' or 'put'
     - precision: Desired precision
@@ -233,46 +233,46 @@ def iv(option_price: float, s: float, k: float, r: float, t: float,
 
     # Check if option price is within theoretical bounds
     if option_type.lower() in ["call", "c"]:
-        intrinsic = max(0, s - k * np.exp(-r * t))
+        intrinsic = max(0, s - K * np.exp(-r * t))
         if option_price < intrinsic:
             return np.nan  # Price below intrinsic value
         if option_price >= s:
             return np.inf  # Price exceeds underlying
     else:  # put
-        intrinsic = max(0, k * np.exp(-r * t) - s)
+        intrinsic = max(0, K * np.exp(-r * t) - s)
         if option_price < intrinsic:
             return np.nan  # Price below intrinsic value
-        if option_price >= k:
+        if option_price >= K:
             return np.inf  # Price exceeds strike
 
     # Initial guess - Manaster and Koehler (1982) method
-    vol = np.sqrt(2 * np.pi / t) * option_price / s
+    o = np.sqrt(2 * np.pi / t) * option_price / s
 
     # Ensure initial guess is reasonable
-    vol = max(0.001, min(vol, 5.0))
+    o = max(0.001, min(o, 5.0))
 
     for _ in range(max_iterations):
         # Calculate option price and vega with current volatility
-        price = bs(s, k, r, vol, t, option_type)
-        v = vega(s, k, r, vol, t, option_type)
+        price = bs(s, K, r, o, t, option_type)
+        v = vega(s, K, r, o, t, option_type)
 
         # Calculate price difference
         price_diff = price - option_price
 
         # Check if precision reached
         if abs(price_diff) < precision:
-            return vol
+            return o
 
         # Avoid division by zero
         if abs(v) < 1e-10:
             # Change direction based on whether price is too high or too low
-            vol = vol * 1.5 if price_diff < 0 else vol * 0.5
+            o = o * 1.5 if price_diff < 0 else o * 0.5
         else:
             # Newton-Raphson update
-            vol = vol - price_diff / (v * 100)  # Vega is for 1% change
+            o = o - price_diff / (v * 100)  # Vega is for 1% change
 
         # Ensure volatility stays in reasonable bounds
-        vol = max(0.001, min(vol, 5.0))
+        o = max(0.001, min(o, 5.0))
 
     # If we reach here, we didn't converge
     return np.nan
@@ -286,7 +286,7 @@ def get_domain(domain_params: Tuple[float, float, int] = (-1.5, 1.5, 1000),
                t: float = None,
                return_domain: str = 'log_moneyness') -> np.ndarray:
     """
-    Compute the x-domain for a given return type (log-moneyness, moneyness, strikes, or delta).
+    Compute the x-domain for a given return type (log-moneyness, moneyness, returns, strikes, or delta).
 
     Parameters:
     -----------
@@ -336,7 +336,7 @@ def get_domain(domain_params: Tuple[float, float, int] = (-1.5, 1.5, 1000),
 
     elif return_domain == 'delta':
         # Check for required parameters
-        required_params = {'s': s, 'o': o, 'r': r, 't': t}
+        required_params = {'s': s, 'r': r, 'o': o, 't': t}
         missing_params = [param for param, value in required_params.items() if value is None]
         if missing_params:
             raise ValueError(f"The following parameters are required for return_domain='delta': {missing_params}")
@@ -355,4 +355,4 @@ def get_domain(domain_params: Tuple[float, float, int] = (-1.5, 1.5, 1000),
 
     else:
         raise ValueError(
-            f"Invalid return_domain: {return_domain}. Must be one of ['log_moneyness', 'moneyness', 'returns', 'strikes', 'delta'].")
+            f"Invalid return_domain: {return_domain}. Must be one of ['log_moneyness', 'moneyness', 'returns', 'striKes', 'delta'].")

{voly-0.0.95 → voly-0.0.97/src/voly.egg-info}/PKG-INFO

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