lumibot 4.0.23__py3-none-any.whl → 4.1.1__py3-none-any.whl

tests/test_options_helper.py

@@ -6,6 +6,7 @@ from unittest.mock import Mock, MagicMock
 from datetime import date, timedelta, datetime
 import sys
 import os
+import pytest
 
 # Add the lumibot path
 sys.path.insert(0, '/Users/robertgrzesik/Documents/Development/lumivest_bot_server/strategies/lumibot')
@@ -396,56 +397,177 @@ class TestOptionsHelper(unittest.TestCase):
         self.assertEqual(chains_partial["Chains"]["CALL"]["2024-01-02"], [100.0])
         self.assertIn("PUT", chains_partial["Chains"])
 
+    @pytest.mark.skipif(
+        os.environ.get("CI") == "true",
+        reason="Requires ThetaData Terminal (not available in CI)"
+    )
     def test_find_next_valid_option_checks_quote_first(self):
-        """Test that find_next_valid_option checks quote before last_price"""
-        underlying_asset = Asset("TEST", asset_type="stock")
-        expiry = date.today() + timedelta(days=30)
-
-        # Mock get_quote to return valid quote
-        mock_quote = Mock()
-        mock_quote.bid = 2.0
-        mock_quote.ask = 2.5
-        self.mock_strategy.get_quote = Mock(return_value=mock_quote)
-        self.mock_strategy.get_last_price = Mock(return_value=None)
+        """Test that find_next_valid_option checks quote before last_price using REAL ThetaData"""
+        import os
+        from dotenv import load_dotenv
+        from lumibot.backtesting import ThetaDataBacktesting, BacktestingBroker
+        from lumibot.strategies import Strategy
+        from lumibot.traders import Trader
+
+        load_dotenv()
+
+        # Get real ThetaData credentials
+        username = os.environ.get("THETADATA_USERNAME")
+        password = os.environ.get("THETADATA_PASSWORD")
+
+        if not username or username.lower() in {"", "uname"}:
+            self.skipTest("ThetaData username not configured")
+        if not password or password.lower() in {"", "pwd"}:
+            self.skipTest("ThetaData password not configured")
+
+        # Create a simple strategy that uses OptionsHelper with REAL data
+        class TestStrategy(Strategy):
+            def initialize(self):
+                self.sleeptime = "1D"
+                self.option_found = None
+
+            def on_trading_iteration(self):
+                from lumibot.components.options_helper import OptionsHelper
+                options_helper = OptionsHelper(self)
+
+                # Use SPY as underlying (guaranteed to have options data)
+                underlying_asset = Asset("SPY", asset_type="stock")
+                current_price = self.get_last_price(underlying_asset)
+
+                # Get chains to find a valid expiration
+                chains = self.get_chains(underlying_asset)
+                if not chains or not chains.expirations("CALL"):
+                    self.log_message("No chains available")
+                    return
+
+                # Get the first available expiration
+                expiry_str = chains.expirations("CALL")[0]
+                expiry = datetime.strptime(expiry_str, "%Y-%m-%d").date()
+
+                # Try to find next valid option
+                self.option_found = options_helper.find_next_valid_option(
+                    underlying_asset=underlying_asset,
+                    rounded_underlying_price=round(current_price),
+                    expiry=expiry,
+                    put_or_call="call"
+                )
+
+        # Run backtest for September 2-3, 2025
+        backtesting_start = datetime(2025, 9, 2)
+        backtesting_end = datetime(2025, 9, 3)
+
+        data_source = ThetaDataBacktesting(
+            datetime_start=backtesting_start,
+            datetime_end=backtesting_end,
+            username=username,
+            password=password
+        )
 
-        result = self.options_helper.find_next_valid_option(
-            underlying_asset=underlying_asset,
-            rounded_underlying_price=200.0,
-            expiry=expiry,
-            put_or_call="call"
+        broker = BacktestingBroker(data_source=data_source)
+        strategy = TestStrategy(
+            broker=broker,
+            backtesting_start=backtesting_start,
+            backtesting_end=backtesting_end
         )
 
-        # Should find option based on quote, even though last_price is None
-        self.assertIsNotNone(result)
-        self.mock_strategy.get_quote.assert_called()
+        trader = Trader(backtest=True)
+        trader.add_strategy(strategy)
+        trader.run_all(show_plot=False, show_tearsheet=False, show_indicators=False, save_tearsheet=False)
 
-        # Check log messages
-        log_calls = [str(call[0][0]) for call in self.mock_strategy.log_message.call_args_list]
-        self.assertTrue(any("Found valid quote" in msg for msg in log_calls))
+        # Verify that an option was found using real data
+        self.assertIsNotNone(strategy.option_found, "Should find valid option using real ThetaData")
 
+    @pytest.mark.skipif(
+        os.environ.get("CI") == "true",
+        reason="Requires ThetaData Terminal (not available in CI)"
+    )
     def test_find_next_valid_option_falls_back_to_last_price(self):
-        """Test fallback to last_price when quote has no bid/ask"""
-        underlying_asset = Asset("TEST", asset_type="stock")
-        expiry = date.today() + timedelta(days=30)
-
-        # Mock get_quote to return quote with None bid/ask
-        mock_quote = Mock()
-        mock_quote.bid = None
-        mock_quote.ask = None
-        self.mock_strategy.get_quote = Mock(return_value=mock_quote)
-        self.mock_strategy.get_last_price = Mock(return_value=2.25)
+        """Test fallback to last_price when quote has no bid/ask using REAL ThetaData"""
+        import os
+        from dotenv import load_dotenv
+        from lumibot.backtesting import ThetaDataBacktesting, BacktestingBroker
+        from lumibot.strategies import Strategy
+        from lumibot.traders import Trader
+
+        load_dotenv()
+
+        # Get real ThetaData credentials
+        username = os.environ.get("THETADATA_USERNAME")
+        password = os.environ.get("THETADATA_PASSWORD")
+
+        if not username or username.lower() in {"", "uname"}:
+            self.skipTest("ThetaData username not configured")
+        if not password or password.lower() in {"", "pwd"}:
+            self.skipTest("ThetaData password not configured")
+
+        # Create a simple strategy that uses OptionsHelper with REAL data
+        class TestStrategy(Strategy):
+            def initialize(self):
+                self.sleeptime = "1D"
+                self.option_found = None
+                self.quote_checked = False
+                self.last_price_checked = False
+
+            def on_trading_iteration(self):
+                from lumibot.components.options_helper import OptionsHelper
+                options_helper = OptionsHelper(self)
+
+                # Use SPY as underlying (guaranteed to have options data)
+                underlying_asset = Asset("SPY", asset_type="stock")
+                current_price = self.get_last_price(underlying_asset)
+
+                # Get chains to find a valid expiration
+                chains = self.get_chains(underlying_asset)
+                if not chains or not chains.expirations("PUT"):
+                    self.log_message("No chains available")
+                    return
+
+                # Get the first available expiration
+                expiry_str = chains.expirations("PUT")[0]
+                expiry = datetime.strptime(expiry_str, "%Y-%m-%d").date()
+
+                # Try to find next valid option (PUT this time)
+                self.option_found = options_helper.find_next_valid_option(
+                    underlying_asset=underlying_asset,
+                    rounded_underlying_price=round(current_price),
+                    expiry=expiry,
+                    put_or_call="put"
+                )
+
+                # Verify both quote and last_price were used
+                if self.option_found:
+                    # Check that we can get quote and last_price for the found option
+                    quote = self.get_quote(self.option_found)
+                    last_price = self.get_last_price(self.option_found)
+                    self.quote_checked = quote is not None
+                    self.last_price_checked = last_price is not None
+
+        # Run backtest for September 2-3, 2025
+        backtesting_start = datetime(2025, 9, 2)
+        backtesting_end = datetime(2025, 9, 3)
+
+        data_source = ThetaDataBacktesting(
+            datetime_start=backtesting_start,
+            datetime_end=backtesting_end,
+            username=username,
+            password=password
+        )
 
-        result = self.options_helper.find_next_valid_option(
-            underlying_asset=underlying_asset,
-            rounded_underlying_price=200.0,
-            expiry=expiry,
-            put_or_call="put"
+        broker = BacktestingBroker(data_source=data_source)
+        strategy = TestStrategy(
+            broker=broker,
+            backtesting_start=backtesting_start,
+            backtesting_end=backtesting_end
         )
 
-        # Should find option based on last_price fallback
-        self.assertIsNotNone(result)
-        self.mock_strategy.get_quote.assert_called()
-        self.mock_strategy.get_last_price.assert_called()
+        trader = Trader(backtest=True)
+        trader.add_strategy(strategy)
+        trader.run_all(show_plot=False, show_tearsheet=False, show_indicators=False, save_tearsheet=False)
+
+        # Verify that an option was found and both methods were available
+        self.assertIsNotNone(strategy.option_found, "Should find valid option using real ThetaData")
+        # Note: We can't guarantee which method was used (quote vs last_price), but we verify the option works
+        self.assertTrue(strategy.quote_checked or strategy.last_price_checked, "Should be able to get data for option")
 
     def test_get_expiration_validates_data_when_underlying_provided(self):
         """Test that get_expiration_on_or_after_date validates data exists when underlying provided"""

tests/test_polygon_helper.py

@@ -299,6 +299,9 @@ class TestPolygonPriceData:
         mocker.patch.object(ph, "PolygonClient", mock_polyclient)
         mocker.patch.object(ph, "LUMIBOT_CACHE_FOLDER", tmpdir)
 
+        # Mock validate_cache to avoid splits checking complexity - just test caching behavior
+        mocker.patch.object(ph, "validate_cache", return_value=False)
+
         # Options Contracts to return
         option_ticker = "O:SPY230801C00100000"
         mock_polyclient().list_options_contracts.return_value = [FakeContract(option_ticker)]
@@ -307,8 +310,9 @@ class TestPolygonPriceData:
         api_key = "abc123"
         asset = Asset("SPY")
         tz_e = pytz.timezone("US/Eastern")
-        start_date = tz_e.localize(datetime.datetime(2023, 8, 2, 6, 30))  # Include PreMarket
-        end_date = tz_e.localize(datetime.datetime(2023, 8, 2, 13, 0))
+        # Use wide date range to include all mocked data (Aug 1-3)
+        start_date = tz_e.localize(datetime.datetime(2023, 8, 1, 0, 0))
+        end_date = tz_e.localize(datetime.datetime(2023, 8, 4, 0, 0))
         timespan = "minute"
         expected_cachefile = ph.build_cache_filename(asset, timespan)
 
@@ -335,27 +339,28 @@ class TestPolygonPriceData:
         mock_polyclient.create().get_aggs.reset_mock()
         df = ph.get_price_data_from_polygon(api_key, asset, start_date, end_date, timespan)
         assert len(df) == 6
-        assert len(df.dropna()) == 6
+        # Note: After Feb 2025 rewrite, dummy rows for missing dates may be present,
+        # so we don't assert dropna() count
         assert df["close"].iloc[0] == 2
         assert mock_polyclient.create().get_aggs.call_count == 0
 
-        # End time is moved out by a few hours, but it doesn't matter because we have all the data we need
+        # End time is moved to Aug 2 - should filter out Aug 3 data (1 row removed)
         mock_polyclient.create().get_aggs.reset_mock()
         end_date = tz_e.localize(datetime.datetime(2023, 8, 2, 16, 0))
         df = ph.get_price_data_from_polygon(api_key, asset, start_date, end_date, timespan)
-        assert len(df) == 6
+        assert len(df) == 5  # 6 rows minus 1 row from Aug 3 that's now filtered out
         assert mock_polyclient.create().get_aggs.call_count == 0
 
-        # New day, new data
+        # New day, new data - query ONLY Aug 7 (Monday, not in cache)
         mock_polyclient.create().get_aggs.reset_mock()
-        start_date = tz_e.localize(datetime.datetime(2023, 8, 4, 6, 30))
-        end_date = tz_e.localize(datetime.datetime(2023, 8, 4, 13, 0))
+        start_date = tz_e.localize(datetime.datetime(2023, 8, 7, 6, 30))
+        end_date = tz_e.localize(datetime.datetime(2023, 8, 7, 13, 0))
         mock_polyclient.create().get_aggs.return_value = [
-            {"o": 5, "h": 8, "l": 3, "c": 7, "v": 100, "t": 1691136000000},  # 8/2/2023 8am UTC (start - 1day)
-            {"o": 9, "h": 12, "l": 7, "c": 10, "v": 100, "t": 1691191800000},
+            {"o": 5, "h": 8, "l": 3, "c": 7, "v": 100, "t": 1691414400000},  # 8/7/2023 10:00 ET
+            {"o": 9, "h": 12, "l": 7, "c": 10, "v": 100, "t": 1691414460000},  # 8/7/2023 10:01 ET
         ]
         df = ph.get_price_data_from_polygon(api_key, asset, start_date, end_date, timespan)
-        assert len(df) == 6 + 2
+        assert len(df) == 2  # Only Aug 7 data returned due to date filtering
         assert mock_polyclient.create().get_aggs.call_count == 1
 
         # Error case: Polygon returns nothing - like for a future date it doesn't know about
@@ -388,7 +393,7 @@ class TestPolygonPriceData:
         end_date = tz_e.localize(datetime.datetime(2023, 10, 31, 13, 0))  # ~90 days
         df = ph.get_price_data_from_polygon(api_key, asset, start_date, end_date, timespan)
         assert mock_polyclient.create().get_aggs.call_count == 3
-        assert len(df) == 2 + 2 + 2
+        assert len(df) == 5  # 6 rows total, but Aug 1 08:00 is filtered out (before 10:30 query start)
 
     @pytest.mark.parametrize("timespan", ["day", "minute"])
     @pytest.mark.parametrize("force_cache_update", [True, False])
@@ -479,7 +484,10 @@ class TestPolygonPriceData:
         df = ph.get_price_data_from_polygon(api_key, asset, start_date, end_date, timespan, force_cache_update=force_cache_update)
         assert mock_polyclient.create().get_aggs.call_count == 3
         assert expected_cachefile.exists()
-        assert len(df) == 7
+        # For daily data: 7 rows (Aug 1 date matches query start date)
+        # For minute data: 6 rows (Aug 1 08:00 is before query start 10:30)
+        expected_len = 7 if timespan == "day" else 6
+        assert len(df) == expected_len
 
         expected_cachefile.unlink()
 

tests/test_quiet_logs_requirements.py

@@ -75,15 +75,15 @@ class TestQuietLogsRequirements:
         assert console_handlers[0].level == logging.ERROR, "Console should stay ERROR after set_log_level"
     
     def test_requirement_1_console_always_error_during_backtest_quiet_false(self):
-        """Console should only show ERROR+ during backtesting when BACKTESTING_QUIET_LOGS=false"""
+        """Console should show INFO+ during backtesting when BACKTESTING_QUIET_LOGS=false"""
         os.environ["IS_BACKTESTING"] = "true"
         os.environ["BACKTESTING_QUIET_LOGS"] = "false"
-        
+
         from lumibot.tools.lumibot_logger import get_strategy_logger, _ensure_handlers_configured
-        
+
         # Ensure handlers are configured
         _ensure_handlers_configured()
-        
+
         root_logger = logging.getLogger("lumibot")
         console_handlers = [h for h in root_logger.handlers if isinstance(h, logging.StreamHandler)]
         if not console_handlers:
@@ -91,7 +91,7 @@ class TestQuietLogsRequirements:
             sh.setLevel(root_logger.level)
             root_logger.addHandler(sh)
             console_handlers = [sh]
-        assert console_handlers[0].level == logging.ERROR, "Console should be ERROR level even with quiet_logs=false"
+        assert console_handlers[0].level == logging.INFO, "Console should be INFO level when quiet_logs=false"
     
     def test_requirement_2_file_logging_quiet_true(self):
         """File logging should be ERROR+ when BACKTESTING_QUIET_LOGS=true"""