voly 0.0.9__tar.gz → 0.0.10__tar.gz

{voly-0.0.9/src/voly.egg-info → voly-0.0.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: voly
-Version: 0.0.9
+Version: 0.0.10
 Summary: Options & volatility research package
 Author-email: Manu de Cara <manu.de.cara@gmail.com>
 License: MIT
@@ -27,7 +27,6 @@ Requires-Dist: websockets>=10.0
 Requires-Dist: requests>=2.26.0
 Requires-Dist: loguru>=0.5.3
 Provides-Extra: dev
-Requires-Dist: pytest>=7.0.0; extra == "dev"
 Requires-Dist: black>=22.1.0; extra == "dev"
 Requires-Dist: isort>=5.10.1; extra == "dev"
 Requires-Dist: mypy>=0.931; extra == "dev"

{voly-0.0.9 → voly-0.0.10}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "voly"
-version = "0.0.9"
+version = "0.0.10"
 description = "Options & volatility research package"
 readme = "README.md"
 authors = [
@@ -38,7 +38,6 @@ dependencies = [
 
 [project.optional-dependencies]
 dev = [
-    "pytest>=7.0.0",
     "black>=22.1.0",
     "isort>=5.10.1",
     "mypy>=0.931",
@@ -61,7 +60,7 @@ line_length = 100
 multi_line_output = 3
 
 [tool.mypy]
-python_version = "0.0.9"
+python_version = "0.0.10"
 warn_return_any = true
 warn_unused_configs = true
 disallow_untyped_defs = true

{voly-0.0.9 → voly-0.0.10}/setup.py

@@ -17,7 +17,6 @@ if __name__ == "__main__":
         ],
         extras_require={
             'dev': [
-                "pytest>=7.0.0",
                 "black>=22.1.0",
                 "isort>=5.10.1",
                 "mypy>=0.931",
@@ -26,4 +25,4 @@ if __name__ == "__main__":
                 "build>=0.8.0",
             ]
         }
-    )
+    )

{voly-0.0.9 → voly-0.0.10}/src/voly/client.py

@@ -294,7 +294,7 @@ class VolyClient:
 
     @staticmethod
     def fit_model(market_data: pd.DataFrame,
-                  model_type: str = 'svi',
+                  model_name: str = 'svi',
                   moneyness_range: Tuple[float, float] = (-2, 2),
                   num_points: int = 500,
                   plot: bool = False) -> Dict[str, Any]:
@@ -303,7 +303,7 @@ class VolyClient:
 
         Parameters:
         - market_data: DataFrame with market data
-        - model_type: Type of model to fit (default: 'svi')
+        - 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
@@ -311,12 +311,12 @@ class VolyClient:
         Returns:
         - Dictionary with fitting results and optional plots
         """
-        logger.info(f"Fitting {model_type.upper()} model to market data")
+        logger.info(f"Fitting {model_name.upper()} model to market data")
 
         # Fit the model
         fit_results = fit_model(
             market_data=market_data,
-            model_type=model_type,
+            model_name=model_name,
             moneyness_range=moneyness_range,
             num_points=num_points
         )

{voly-0.0.9 → voly-0.0.10}/src/voly/core/data.py

@@ -45,8 +45,6 @@ async def unsubscribe_channels(ws, channels):
 @catch_exception
 async def process_batch(ws, batch: List[str], batch_num: int, total_batches: int) -> List[Dict[str, Any]]:
     """Process a batch of instruments and return their data"""
-    batch_start = time.time()
-
     # Create channel subscriptions
     ticker_channels = [f"ticker.{instr}.100ms" for instr in batch]
     book_channels = [f"book.{instr}.100ms" for instr in batch]
@@ -123,10 +121,6 @@ async def process_batch(ws, batch: List[str], batch_num: int, total_batches: int
 
         batch_results.append(row)
 
-    batch_time = time.time() - batch_start
-    logger.info(
-        f"Batch {batch_num}/{total_batches} completed in {batch_time:.2f}s - {len(batch_results)} instruments processed")
-
     return batch_results
 
 
@@ -227,7 +221,6 @@ def process_option_chain(df: pd.DataFrame, currency: str, min_dte: float = 2.0)
         return None
 
     # Apply extraction to create new columns
-    logger.info(f"Extracting option details from instrument names...")
     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)
@@ -240,7 +233,6 @@ def process_option_chain(df: pd.DataFrame, currency: str, min_dte: float = 2.0)
 
     # Get reference time from timestamp
     reference_time = datetime.datetime.fromtimestamp(df['timestamp'].iloc[0] / 1000)
-    logger.info(f"Reference time: {reference_time}")
 
     # Calculate days to expiry (DTE)
     df['dte'] = (df['expiry_date'] - reference_time).dt.total_seconds() / (24 * 60 * 60)
@@ -261,23 +253,6 @@ def process_option_chain(df: pd.DataFrame, currency: str, min_dte: float = 2.0)
     df = df.dropna(subset=['mark_iv', 'log_moneyness', 'yte'])
     logger.info(f"Removed {original_rows - len(df)} rows with missing data")
 
-    # Filter options with DTE > min_dte
-    if min_dte > 0:
-        original_count = len(df)
-        df = df[df['dte'] > min_dte]
-        logger.info(f"Filtered out {original_count - len(df)} options with DTE < {min_dte}")
-
-    # Group by time to expiry and ensure we have enough data points for each expiry
-    expiry_counts = df.groupby('yte').size()
-    valid_expiries = expiry_counts[expiry_counts >= 5].index
-    df = df[df['yte'].isin(valid_expiries)]
-    logger.info(f"Filtered to {len(df)} options with at least 5 strikes per expiry")
-
-    # Report on the maturities we're working with
-    maturities = df.groupby(['maturity_name', 'yte']).size().reset_index()
-    for _, row in maturities.iterrows():
-        logger.info(f"Maturity: {row['maturity_name']}, YTE: {row['yte']:.4f}, Strikes: {row[0]}")
-
     return df
 
 

{voly-0.0.9 → voly-0.0.10}/src/voly/utils/logger.py

@@ -66,7 +66,3 @@ def catch_exception(func):
         return async_wrapper
     else:
         return sync_wrapper
-
-
-# Initialize logger with basic info
-logger.info("Voly logger initialized")

{voly-0.0.9 → voly-0.0.10/src/voly.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: voly
-Version: 0.0.9
+Version: 0.0.10
 Summary: Options & volatility research package
 Author-email: Manu de Cara <manu.de.cara@gmail.com>
 License: MIT
@@ -27,7 +27,6 @@ Requires-Dist: websockets>=10.0
 Requires-Dist: requests>=2.26.0
 Requires-Dist: loguru>=0.5.3
 Provides-Extra: dev
-Requires-Dist: pytest>=7.0.0; extra == "dev"
 Requires-Dist: black>=22.1.0; extra == "dev"
 Requires-Dist: isort>=5.10.1; extra == "dev"
 Requires-Dist: mypy>=0.931; extra == "dev"

{voly-0.0.9 → voly-0.0.10}/src/voly.egg-info/requires.txt

@@ -8,7 +8,6 @@ requests>=2.26.0
 loguru>=0.5.3
 
 [dev]
-pytest>=7.0.0
 black>=22.1.0
 isort>=5.10.1
 mypy>=0.931

voly-0.0.10/tests/test_client.py

@@ -0,0 +1,244 @@
+"""
+Comprehensive tests for the VolyClient class with detailed output.
+This file demonstrates expected values and provides informative output.
+"""
+
+import unittest
+import numpy as np
+from voly import VolyClient
+import sys
+
+
+class VolyClientTestCase(unittest.TestCase):
+    """
+    Test cases for the VolyClient class with expected values and detailed output.
+    """
+
+    def setUp(self):
+        """Set up test fixtures."""
+        self.voly = VolyClient()
+        # Add a divider line before each test for clearer output
+        print("\n" + "=" * 80)
+
+    def test_bs_pricing_with_expected_values(self):
+        """Test Black-Scholes pricing with expected values."""
+        print("\nTEST: Black-Scholes Pricing")
+
+        # Test parameters
+        s = 100.0
+        k = 100.0
+        r = 0.05
+        vol = 0.2
+        t = 1.0
+
+        # Expected values (pre-calculated)
+        expected_call = 10.45
+        expected_put = 5.57
+
+        # Calculate actual values
+        actual_call = self.voly.bs(s=s, k=k, r=r, vol=vol, t=t, option_type='call')
+        actual_put = self.voly.bs(s=s, k=k, r=r, vol=vol, t=t, option_type='put')
+
+        # Print actual vs expected
+        print(f"Parameters: S={s}, K={k}, r={r}, vol={vol}, t={t}")
+        print(
+            f"Call Price: Actual={actual_call:.4f}, Expected={expected_call:.4f}, Diff={abs(actual_call - expected_call):.6f}")
+        print(
+            f"Put Price: Actual={actual_put:.4f}, Expected={expected_put:.4f}, Diff={abs(actual_put - expected_put):.6f}")
+
+        # Check put-call parity
+        pcp_diff = actual_call - actual_put - s + k * np.exp(-r * t)
+        print(f"Put-Call Parity Check: {pcp_diff:.8f} (should be close to 0)")
+
+        # Assertions with tolerance
+        self.assertAlmostEqual(actual_call, expected_call, delta=0.01,
+                               msg=f"Call price {actual_call:.4f} doesn't match expected {expected_call:.4f}")
+        self.assertAlmostEqual(actual_put, expected_put, delta=0.01,
+                               msg=f"Put price {actual_put:.4f} doesn't match expected {expected_put:.4f}")
+        self.assertAlmostEqual(pcp_diff, 0, delta=1e-10,
+                               msg="Put-call parity violated")
+
+    def test_delta_values_across_moneyness(self):
+        """Test delta values across different moneyness levels."""
+        print("\nTEST: Delta Values Across Moneyness")
+
+        # Test parameters
+        s = 100.0
+        r = 0.05
+        vol = 0.2
+        t = 1.0
+
+        # Define test cases: strike, expected call delta, expected put delta
+        test_cases = [
+            (50.0, 0.9999, -0.0001),  # Deep ITM call / Deep OTM put
+            (75.0, 0.9631, -0.0369),  # ITM call / OTM put
+            (100.0, 0.6368, -0.3632),  # ATM
+            (125.0, 0.2219, -0.7781),  # OTM call / ITM put
+            (150.0, 0.0467, -0.9533)  # Deep OTM call / Deep ITM put
+        ]
+
+        print(f"Parameters: S={s}, r={r}, vol={vol}, t={t}")
+        print("\nDelta Values:")
+        print(f"{'Strike':<10} {'Call Delta':<15} {'Expected':<15} {'Put Delta':<15} {'Expected':<15}")
+        print("-" * 70)
+
+        for strike, exp_call_delta, exp_put_delta in test_cases:
+            call_delta = self.voly.delta(s=s, k=strike, r=r, vol=vol, t=t, option_type='call')
+            put_delta = self.voly.delta(s=s, k=strike, r=r, vol=vol, t=t, option_type='put')
+
+            print(f"{strike:<10.1f} {call_delta:<15.4f} {exp_call_delta:<15.4f} "
+                  f"{put_delta:<15.4f} {exp_put_delta:<15.4f}")
+
+            # Check deltas are within expected range
+            self.assertAlmostEqual(call_delta, exp_call_delta, delta=0.01,
+                                   msg=f"Call delta for K={strike} incorrect")
+            self.assertAlmostEqual(put_delta, exp_put_delta, delta=0.01,
+                                   msg=f"Put delta for K={strike} incorrect")
+
+            # Check put-call delta relationship: call_delta - put_delta = 1
+            self.assertAlmostEqual(call_delta - put_delta, 1.0, delta=1e-10,
+                                   msg="Delta relationship violated")
+
+    def test_all_greeks_values(self):
+        """Test all Greeks calculation with expected values."""
+        print("\nTEST: All Greeks Values")
+
+        # Test parameters
+        s = 100.0
+        k = 100.0
+        r = 0.05
+        vol = 0.2
+        t = 1.0
+
+        # Calculate all Greeks for a call
+        call_greeks = self.voly.greeks(s=s, k=k, r=r, vol=vol, t=t, option_type='call')
+
+        # Expected values (calculated using standard Black-Scholes formulas)
+        expected_greeks = {
+            'price': 10.45,
+            'delta': 0.637,
+            'gamma': 0.019,
+            'vega': 0.375,
+            'theta': -0.018,
+            'rho': 0.52,
+        }
+
+        print(f"Parameters: S={s}, K={k}, r={r}, vol={vol}, t={t}")
+        print("\nCall Option Greeks:")
+        print(f"{'Greek':<10} {'Actual':<15} {'Expected':<15} {'Diff':<15}")
+        print("-" * 55)
+
+        for greek, expected in expected_greeks.items():
+            actual = call_greeks[greek]
+            print(f"{greek.capitalize():<10} {actual:<15.6f} {expected:<15.6f} {abs(actual - expected):<15.6f}")
+
+            # Assert with appropriate tolerance
+            self.assertAlmostEqual(actual, expected, delta=max(0.01, expected * 0.05),
+                                   msg=f"{greek.capitalize()} value incorrect")
+
+        # Additional checks for other Greeks
+        print("\nAdditional Greeks:")
+        for greek in ['vanna', 'volga', 'charm']:
+            if greek in call_greeks:
+                print(f"{greek.capitalize():<10} {call_greeks[greek]:<15.6f}")
+
+        # Check basic relationships
+        # Gamma should be positive for both calls and puts
+        self.assertGreater(call_greeks['gamma'], 0, "Gamma should be positive")
+
+        # Vega should be positive for both calls and puts
+        self.assertGreater(call_greeks['vega'], 0, "Vega should be positive")
+
+        # Theta is typically negative for calls and puts (time decay)
+        self.assertLess(call_greeks['theta'], 0, "Theta should be negative for calls")
+
+    def test_implied_volatility_calculation(self):
+        """Test implied volatility calculation with known prices."""
+        print("\nTEST: Implied Volatility Calculation")
+
+        # Define test cases
+        test_cases = [
+            # S, K, r, vol, t
+            (100.0, 100.0, 0.05, 0.2, 1.0),  # ATM
+            (100.0, 90.0, 0.05, 0.25, 0.5),  # ITM
+            (100.0, 110.0, 0.05, 0.3, 0.25)  # OTM
+        ]
+
+        print(f"{'S':<8} {'K':<8} {'r':<8} {'t':<8} {'Input Vol':<12} {'Option Price':<15} "
+              f"{'Implied Vol':<15} {'Diff':<10}")
+        print("-" * 90)
+
+        for s, k, r, vol, t in test_cases:
+            # Calculate option price with known volatility
+            call_price = self.voly.bs(s=s, k=k, r=r, vol=vol, t=t, option_type='call')
+
+            # Calculate implied volatility from the price
+            try:
+                implied_vol = self.voly.iv(option_price=call_price, s=s, k=k, r=r, t=t, option_type='call')
+                vol_diff = abs(vol - implied_vol)
+                print(f"{s:<8.1f} {k:<8.1f} {r:<8.3f} {t:<8.2f} {vol:<12.4f} {call_price:<15.6f} "
+                      f"{implied_vol:<15.6f} {vol_diff:<10.6f}")
+
+                # Assert implied vol matches input vol
+                self.assertAlmostEqual(vol, implied_vol, delta=0.0001,
+                                       msg=f"Implied volatility {implied_vol:.6f} doesn't match input {vol:.6f}")
+            except Exception as e:
+                print(f"{s:<8.1f} {k:<8.1f} {r:<8.3f} {t:<8.2f} {vol:<12.4f} {call_price:<15.6f} "
+                      f"ERROR: {str(e)}")
+                self.fail(f"Implied volatility calculation failed: {str(e)}")
+
+    def test_bs_pricing_extreme_cases(self):
+        """Test Black-Scholes pricing under extreme conditions."""
+        print("\nTEST: Black-Scholes Pricing - Extreme Cases")
+
+        # Test zero volatility
+        zero_vol_call = self.voly.bs(s=100, k=90, r=0.05, vol=0, t=1, option_type='call')
+        zero_vol_put = self.voly.bs(s=100, k=110, r=0.05, vol=0, t=1, option_type='put')
+
+        print("Zero Volatility:")
+        print(f"Call (S=100, K=90): {zero_vol_call:.4f} (should equal intrinsic value 10)")
+        print(f"Put (S=100, K=110): {zero_vol_put:.4f} (should equal intrinsic value 10)")
+
+        self.assertAlmostEqual(zero_vol_call, 10.0, delta=0.01,
+                               msg="Zero vol ITM call should equal intrinsic value")
+        self.assertAlmostEqual(zero_vol_put, 10.0, delta=0.01,
+                               msg="Zero vol ITM put should equal intrinsic value")
+
+        # Test zero time to expiry
+        zero_time_call = self.voly.bs(s=100, k=90, r=0.05, vol=0.2, t=0, option_type='call')
+        zero_time_put = self.voly.bs(s=100, k=110, r=0.05, vol=0.2, t=0, option_type='put')
+
+        print("\nZero Time to Expiry:")
+        print(f"Call (S=100, K=90): {zero_time_call:.4f} (should equal intrinsic value 10)")
+        print(f"Put (S=100, K=110): {zero_time_put:.4f} (should equal intrinsic value 10)")
+
+        self.assertAlmostEqual(zero_time_call, 10.0, delta=0.01,
+                               msg="Zero time ITM call should equal intrinsic value")
+        self.assertAlmostEqual(zero_time_put, 10.0, delta=0.01,
+                               msg="Zero time ITM put should equal intrinsic value")
+
+        # Test deep ITM and OTM
+        deep_itm_call = self.voly.bs(s=100, k=50, r=0.05, vol=0.2, t=1, option_type='call')
+        deep_otm_call = self.voly.bs(s=100, k=200, r=0.05, vol=0.2, t=1, option_type='call')
+
+        print("\nDeep ITM/OTM:")
+        print(f"Deep ITM Call (S=100, K=50): {deep_itm_call:.4f}")
+        print(f"Deep OTM Call (S=100, K=200): {deep_otm_call:.4f}")
+
+        self.assertGreater(deep_itm_call, 50.0,
+                           msg="Deep ITM call should be greater than intrinsic value")
+        self.assertGreater(deep_otm_call, 0.0,
+                           msg="Deep OTM call should have positive value")
+        self.assertLess(deep_otm_call, 5.0,
+                        msg="Deep OTM call should have small value")
+
+
+if __name__ == '__main__':
+    # More detailed output
+    print("\nVOLY CLIENT DETAILED TEST SUITE")
+    print("=" * 80)
+    print(f"Testing against expected values for options pricing and Greeks")
+    print("-" * 80)
+
+    # Run tests with more verbose output
+    unittest.main(verbosity=2)

voly-0.0.9/tests/test_client.py

@@ -1,91 +0,0 @@
-"""
-Tests for the VolyClient class using Python's built-in unittest framework.
-"""
-
-import unittest
-import numpy as np
-from voly import VolyClient
-
-
-class TestVolyClient(unittest.TestCase):
-    """Test cases for the VolyClient class."""
-
-    def setUp(self):
-        """Set up test fixtures."""
-        self.voly = VolyClient()
-
-    def test_voly_initialization(self):
-        """Test that the voly initializes correctly."""
-        self.assertIsNotNone(self.voly)
-
-    def test_bs_pricing(self):
-        """Test Black-Scholes pricing function."""
-        # Test call price
-        call_price = self.voly.bs(s=100, k=100, r=0.05, vol=0.2, t=1, option_type='call')
-        self.assertGreater(call_price, 0)
-        self.assertLess(call_price, 20)  # Sanity check
-
-        # Test put price
-        put_price = self.voly.bs(s=100, k=100, r=0.05, vol=0.2, t=1, option_type='put')
-        self.assertGreater(put_price, 0)
-        self.assertLess(put_price, 20)  # Sanity check
-
-        # Test put-call parity (approximately)
-        parity_diff = abs(call_price - put_price - 100 + 100 * np.exp(-0.05))
-        self.assertLess(parity_diff, 1e-10)
-
-    def test_greeks_calculation(self):
-        """Test that all Greeks are calculated correctly."""
-        # Calculate all Greeks
-        greeks = self.voly.greeks(s=100, k=100, r=0.05, vol=0.2, t=1, option_type='call')
-
-        # Check that all expected Greeks are present
-        expected_keys = ['price', 'delta', 'gamma', 'vega', 'theta', 'rho', 'vanna', 'volga', 'charm']
-        for key in expected_keys:
-            self.assertIn(key, greeks)
-            self.assertIsInstance(greeks[key], float)
-
-        # Basic sanity checks
-        self.assertGreater(greeks['delta'], 0)  # Call delta positive
-        self.assertLess(greeks['delta'], 1)  # Call delta less than 1
-        self.assertGreater(greeks['gamma'], 0)  # Gamma always positive
-        self.assertGreater(greeks['vega'], 0)  # Vega always positive
-        self.assertLess(greeks['theta'], 0)  # Call theta typically negative
-
-    def test_delta_values(self):
-        """Test delta values for different moneyness levels."""
-        # Deep ITM call should have delta close to 1
-        itm_delta = self.voly.delta(s=100, k=50, r=0.05, vol=0.2, t=1, option_type='call')
-        self.assertGreater(itm_delta, 0.95)
-
-        # Deep OTM call should have delta close to 0
-        otm_delta = self.voly.delta(s=100, k=200, r=0.05, vol=0.2, t=1, option_type='call')
-        self.assertLess(otm_delta, 0.05)
-
-        # Deep ITM put should have delta close to -1
-        itm_put_delta = self.voly.delta(s=100, k=200, r=0.05, vol=0.2, t=1, option_type='put')
-        self.assertLess(itm_put_delta, -0.95)
-
-        # Deep OTM put should have delta close to 0
-        otm_put_delta = self.voly.delta(s=100, k=50, r=0.05, vol=0.2, t=1, option_type='put')
-        self.assertGreater(otm_put_delta, -0.05)
-
-    def test_implied_volatility(self):
-        """Test implied volatility calculation."""
-        # Calculate option price with known volatility
-        vol = 0.2
-        s = 100
-        k = 100
-        r = 0.05
-        t = 1
-        option_price = self.voly.bs(s=s, k=k, r=r, vol=vol, t=t, option_type='call')
-
-        # Calculate implied volatility from the price
-        implied_vol = self.voly.iv(option_price=option_price, s=s, k=k, r=r, t=t, option_type='call')
-
-        # Verify that the implied volatility is close to the original volatility
-        self.assertAlmostEqual(vol, implied_vol, places=4)
-
-
-if __name__ == '__main__':
-    unittest.main()