lumibot 4.2.1__tar.gz → 4.2.4__tar.gz

{lumibot-4.2.1/lumibot.egg-info → lumibot-4.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lumibot
-Version: 4.2.1
+Version: 4.2.4
 Summary: Backtesting and Trading Library, Made by Lumiwealth
 Home-page: https://github.com/Lumiwealth/lumibot
 Author: Robert Grzesik

{lumibot-4.2.1 → lumibot-4.2.4}/lumibot/backtesting/thetadata_backtesting_pandas.py

@@ -288,7 +288,8 @@ class ThetaDataBacktestingPandas(PandasData):
         )
 
         expected_last_dt = self.to_default_timezone(current_dt).replace(hour=0, minute=0, second=0, microsecond=0) - timedelta(days=1)
-        target_index = pd.date_range(end=expected_last_dt, periods=requested_length, freq="D", tz=self.tzinfo)
+        expected_last_dt_utc = expected_last_dt.astimezone(pytz.UTC)
+        target_index = pd.date_range(end=expected_last_dt_utc, periods=requested_length, freq="D", tz=pytz.UTC).tz_convert(self.tzinfo)
 
         # DEBUG-LOG: Target index details
         logger.debug(

{lumibot-4.2.1 → lumibot-4.2.4}/lumibot/strategies/_strategy.py

@@ -1388,12 +1388,6 @@ class _Strategy:
         if use_other_option_source and not isinstance(optionsource_class, type):
             raise ValueError(f"`optionsource_class` must be a class. You passed in {optionsource_class}")
 
-        self.verify_backtest_inputs(backtesting_start, backtesting_end)
-
-        if not self.IS_BACKTESTABLE:
-            get_logger(__name__).warning(f"Strategy {name + ' ' if name is not None else ''}cannot be " f"backtested at the moment")
-            return None
-
         try:
             backtesting_start = to_datetime_aware(backtesting_start)
             backtesting_end = to_datetime_aware(backtesting_end)
@@ -1405,6 +1399,12 @@ class _Strategy:
             )
             return None
 
+        self.verify_backtest_inputs(backtesting_start, backtesting_end)
+
+        if not self.IS_BACKTESTABLE:
+            get_logger(__name__).warning(f"Strategy {name + ' ' if name is not None else ''}cannot be " f"backtested at the moment")
+            return None
+
         if BACKTESTING_QUIET_LOGS is not None:
             quiet_logs = BACKTESTING_QUIET_LOGS
 
@@ -1628,18 +1628,21 @@ class _Strategy:
         if not isinstance(backtesting_end, datetime.datetime):
             raise ValueError(f"`backtesting_end` must be a datetime object. You passed in {backtesting_end}")
 
+        start_dt = to_datetime_aware(backtesting_start)
+        end_dt = to_datetime_aware(backtesting_end)
+
         # Check that backtesting end is after backtesting start
-        if backtesting_end <= backtesting_start:
+        if end_dt <= start_dt:
             raise ValueError(
                 f"`backtesting_end` must be after `backtesting_start`. You passed in "
-                f"{backtesting_end} and {backtesting_start}"
+                f"{end_dt} and {start_dt}"
             )
 
         # Check that backtesting_end is not in the future
-        now = datetime.datetime.now(backtesting_end.tzinfo) if backtesting_end.tzinfo else datetime.datetime.now()
-        if backtesting_end > now:
+        now = datetime.datetime.now(end_dt.tzinfo) if end_dt.tzinfo else datetime.datetime.now()
+        if end_dt > now:
             raise ValueError(
-                f"`backtesting_end` cannot be in the future. You passed in {backtesting_end}, now is {now}"
+                f"`backtesting_end` cannot be in the future. You passed in {end_dt}, now is {now}"
             )
 
     def send_update_to_cloud(self):

{lumibot-4.2.1 → lumibot-4.2.4}/lumibot/tools/thetadata_helper.py

@@ -26,6 +26,17 @@ CONNECTION_MAX_RETRIES = 60
 BOOT_GRACE_PERIOD = 5.0
 MAX_RESTART_ATTEMPTS = 3
 
+
+def _resolve_asset_folder(asset_obj: Asset) -> str:
+    asset_type = getattr(asset_obj, "asset_type", None) or "stock"
+    asset_key = str(asset_type).strip().lower()
+    return asset_key
+
+
+def _normalize_folder_component(value: str, fallback: str) -> str:
+    normalized = str(value or "").strip().lower().replace(" ", "_")
+    return normalized or fallback
+
 # Global process tracking for ThetaTerminal
 THETA_DATA_PROCESS = None
 THETA_DATA_PID = None
@@ -785,7 +796,11 @@ def get_trading_dates(asset: Asset, start: datetime, end: datetime):
 def build_cache_filename(asset: Asset, timespan: str, datastyle: str = "ohlc"):
     """Helper function to create the cache filename for a given asset and timespan"""
 
-    lumibot_cache_folder = Path(LUMIBOT_CACHE_FOLDER) / CACHE_SUBFOLDER
+    provider_root = Path(LUMIBOT_CACHE_FOLDER) / CACHE_SUBFOLDER
+    asset_folder = _resolve_asset_folder(asset)
+    timespan_folder = _normalize_folder_component(timespan, "unknown")
+    datastyle_folder = _normalize_folder_component(datastyle, "default")
+    base_folder = provider_root / asset_folder / timespan_folder / datastyle_folder
 
     # If It's an option then also add the expiration date, strike price and right to the filename
     if asset.asset_type == "option":
@@ -799,7 +814,7 @@ def build_cache_filename(asset: Asset, timespan: str, datastyle: str = "ohlc"):
         uniq_str = asset.symbol
 
     cache_filename = f"{asset.asset_type}_{uniq_str}_{timespan}_{datastyle}.parquet"
-    cache_file = lumibot_cache_folder / cache_filename
+    cache_file = base_folder / cache_filename
     return cache_file
 
 
@@ -1969,7 +1984,7 @@ def get_chains_cached(
     Retrieve option chain with caching (MATCHES POLYGON PATTERN).
 
     This function follows the EXACT same caching strategy as Polygon:
-    1. Check cache: LUMIBOT_CACHE_FOLDER/thetadata/option_chains/{symbol}_{date}.parquet
+    1. Check cache: LUMIBOT_CACHE_FOLDER/thetadata/<asset-type>/option_chains/{symbol}_{date}.parquet
     2. Reuse files within RECENT_FILE_TOLERANCE_DAYS (default 7 days)
     3. If not found, fetch from ThetaData and save to cache
     4. Use pyarrow engine with snappy compression
@@ -2006,7 +2021,7 @@ def get_chains_cached(
         return None
 
     # 2) Build cache folder path
-    chain_folder = Path(LUMIBOT_CACHE_FOLDER) / "thetadata" / "option_chains"
+    chain_folder = Path(LUMIBOT_CACHE_FOLDER) / "thetadata" / _resolve_asset_folder(asset) / "option_chains"
     chain_folder.mkdir(parents=True, exist_ok=True)
 
     # 3) Check for recent cached file (within RECENT_FILE_TOLERANCE_DAYS)

{lumibot-4.2.1 → lumibot-4.2.4/lumibot.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lumibot
-Version: 4.2.1
+Version: 4.2.4
 Summary: Backtesting and Trading Library, Made by Lumiwealth
 Home-page: https://github.com/Lumiwealth/lumibot
 Author: Robert Grzesik

{lumibot-4.2.1 → lumibot-4.2.4}/lumibot.egg-info/SOURCES.txt

@@ -167,6 +167,7 @@ tests/test_backtesting_broker_await_close.py
 tests/test_backtesting_broker_time_advance.py
 tests/test_backtesting_crypto_cash_unit.py
 tests/test_backtesting_data_source_env.py
+tests/test_backtesting_datetime_normalization.py
 tests/test_backtesting_flow_control.py
 tests/test_backtesting_multileg_unit.py
 tests/test_backtesting_quiet_logs_complete.py

{lumibot-4.2.1 → lumibot-4.2.4}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setuptools.setup(
     name="lumibot",
-    version="4.2.1",
+    version="4.2.4",
     author="Robert Grzesik",
     author_email="rob@lumiwealth.com",
     description="Backtesting and Trading Library, Made by Lumiwealth",

{lumibot-4.2.1 → lumibot-4.2.4}/tests/test_backtest_cache_manager.py

@@ -67,7 +67,7 @@ def _build_settings(prefix: str = "prod/cache") -> BacktestCacheSettings:
 def test_remote_key_uses_relative_cache_path(tmp_path, monkeypatch):
     cache_root = tmp_path / "cache"
     cache_root.mkdir()
-    local_file = cache_root / "thetadata" / "bars" / "spy.parquet"
+    local_file = cache_root / "thetadata" / "stock" / "minute" / "ohlc" / "stock_SPY_minute_ohlc.parquet"
     local_file.parent.mkdir(parents=True, exist_ok=True)
 
     monkeypatch.setattr(backtest_cache, "LUMIBOT_CACHE_FOLDER", cache_root)
@@ -76,17 +76,17 @@ def test_remote_key_uses_relative_cache_path(tmp_path, monkeypatch):
     manager = BacktestCacheManager(settings, client_factory=lambda settings: StubS3Client())
 
     remote_key = manager.remote_key_for(local_file)
-    assert remote_key == "stage/cache/v3/thetadata/bars/spy.parquet"
+    assert remote_key == "stage/cache/v3/thetadata/stock/minute/ohlc/stock_SPY_minute_ohlc.parquet"
 
 
 def test_ensure_local_file_downloads_from_s3(tmp_path, monkeypatch):
     cache_root = tmp_path / "cache"
     cache_root.mkdir()
-    local_file = cache_root / "thetadata" / "bars" / "spy.parquet"
+    local_file = cache_root / "thetadata" / "stock" / "minute" / "ohlc" / "stock_SPY_minute_ohlc.parquet"
 
     monkeypatch.setattr(backtest_cache, "LUMIBOT_CACHE_FOLDER", cache_root)
 
-    remote_key = "stage/cache/v3/thetadata/bars/spy.parquet"
+    remote_key = "stage/cache/v3/thetadata/stock/minute/ohlc/stock_SPY_minute_ohlc.parquet"
     objects = {("test-bucket", remote_key): b"cached-data"}
 
     stub = StubS3Client(objects)
@@ -101,7 +101,7 @@ def test_ensure_local_file_downloads_from_s3(tmp_path, monkeypatch):
 def test_ensure_local_file_handles_missing_remote(tmp_path, monkeypatch):
     cache_root = tmp_path / "cache"
     cache_root.mkdir()
-    local_file = cache_root / "thetadata" / "bars" / "spy.parquet"
+    local_file = cache_root / "thetadata" / "stock" / "minute" / "ohlc" / "stock_SPY_minute_ohlc.parquet"
 
     monkeypatch.setattr(backtest_cache, "LUMIBOT_CACHE_FOLDER", cache_root)
 
@@ -116,13 +116,13 @@ def test_ensure_local_file_handles_missing_remote(tmp_path, monkeypatch):
 def test_on_local_update_uploads_file(tmp_path, monkeypatch):
     cache_root = tmp_path / "cache"
     cache_root.mkdir()
-    local_file = cache_root / "thetadata" / "bars" / "spy.parquet"
+    local_file = cache_root / "thetadata" / "stock" / "minute" / "ohlc" / "stock_SPY_minute_ohlc.parquet"
     local_file.parent.mkdir(parents=True, exist_ok=True)
     local_file.write_bytes(b"new-data")
 
     monkeypatch.setattr(backtest_cache, "LUMIBOT_CACHE_FOLDER", cache_root)
 
-    remote_key = "stage/cache/v3/thetadata/bars/spy.parquet"
+    remote_key = "stage/cache/v3/thetadata/stock/minute/ohlc/stock_SPY_minute_ohlc.parquet"
     stub = StubS3Client({("test-bucket", remote_key): b"old"})
     manager = BacktestCacheManager(_build_settings(prefix="stage/cache"), client_factory=lambda s: stub)
 

{lumibot-4.2.1 → lumibot-4.2.4}/tests/test_backtesting_data_source_env.py

@@ -75,6 +75,9 @@ class TestBacktestingDataSourceEnv:
         # Configure caplog to capture INFO level logs from lumibot.strategies._strategy
         import logging
         caplog.set_level(logging.INFO, logger='lumibot.strategies._strategy')
+        polygon_key = os.environ.get("POLYGON_API_KEY")
+        if not polygon_key:
+            pytest.skip("Polygon API key not configured")
 
         with patch.dict(os.environ, {'BACKTESTING_DATA_SOURCE': 'polygon'}):
             # Re-import credentials to pick up env change

lumibot-4.2.4/tests/test_backtesting_datetime_normalization.py

@@ -0,0 +1,90 @@
+import datetime
+from unittest.mock import patch
+
+import pytest
+
+from lumibot.strategies import Strategy
+from lumibot.strategies._strategy import _Strategy
+
+
+class MinimalStrategy(Strategy):
+    """No-op strategy used for backtest scaffolding."""
+
+    def initialize(self):
+        self.sleeptime = "1D"
+
+    def on_trading_iteration(self):
+        pass
+
+
+class DummyDataSource:
+    """Lightweight datasource stub capturing the start/end datetimes."""
+
+    SOURCE = "dummy"
+
+    def __init__(self, datetime_start=None, datetime_end=None, **kwargs):
+        self.datetime_start = datetime_start
+        self.datetime_end = datetime_end
+        self._data_store = {}
+
+
+class DummyTrader:
+    """Trader stub that records strategies and returns canned results."""
+
+    def __init__(self, *args, **kwargs):
+        self._strategies = []
+
+    def add_strategy(self, strategy):
+        self._strategies.append(strategy)
+
+    def run_all(self, **_kwargs):
+        return {strategy.name: {"dummy": True} for strategy in self._strategies}
+
+
+class _EarlyExit(Exception):
+    """Signal to stop run_backtest after the datasource is constructed."""
+
+
+def test_verify_backtest_inputs_accepts_mixed_timezones():
+    """Regression: verify_backtest_inputs must not crash on naive vs aware inputs."""
+    naive_start = datetime.datetime(2025, 1, 1)
+    aware_end = datetime.datetime(2025, 9, 30, tzinfo=datetime.timezone.utc)
+
+    # Should not raise
+    _Strategy.verify_backtest_inputs(naive_start, aware_end)
+
+
+def test_run_backtest_normalizes_mixed_timezones():
+    """Strategy.run_backtest should normalize naive/aware datetimes before validation."""
+    naive_start = datetime.datetime(2025, 1, 1)
+    aware_end = datetime.datetime(2025, 9, 30, tzinfo=datetime.timezone.utc)
+
+    captured = {}
+
+    class CapturingDataSource(DummyDataSource):
+        def __init__(self, datetime_start=None, datetime_end=None, **kwargs):
+            super().__init__(datetime_start=datetime_start, datetime_end=datetime_end, **kwargs)
+            captured["start"] = self.datetime_start
+            captured["end"] = self.datetime_end
+
+    def broker_factory(data_source, *args, **kwargs):
+        captured["data_source"] = data_source
+        raise _EarlyExit
+
+    with patch("lumibot.strategies._strategy.BacktestingBroker", side_effect=broker_factory), \
+         patch("lumibot.strategies._strategy.Trader", DummyTrader):
+        with pytest.raises(_EarlyExit):
+            MinimalStrategy.run_backtest(
+                CapturingDataSource,
+                backtesting_start=naive_start,
+                backtesting_end=aware_end,
+                show_plot=False,
+                show_tearsheet=False,
+                show_indicators=False,
+                show_progress_bar=False,
+                save_logfile=False,
+                save_stats_file=False,
+            )
+
+    assert "start" in captured and captured["start"].tzinfo is not None
+    assert "end" in captured and captured["end"].tzinfo is not None

{lumibot-4.2.1 → lumibot-4.2.4}/tests/test_thetadata_helper.py

@@ -324,13 +324,13 @@ def test_get_trading_dates():
 def test_build_cache_filename(mocker, tmpdir, datastyle):
     asset = Asset("SPY")
     timespan = "1D"
-    mocker.patch.object(thetadata_helper, "LUMIBOT_CACHE_FOLDER", tmpdir)
-    expected = tmpdir / "thetadata" / f"stock_SPY_1D_{datastyle}.parquet"
+    mocker.patch.object(thetadata_helper, "LUMIBOT_CACHE_FOLDER", str(tmpdir))
+    expected = tmpdir / "thetadata" / "stock" / "1d" / datastyle / f"stock_SPY_1D_{datastyle}.parquet"
     assert thetadata_helper.build_cache_filename(asset, timespan, datastyle) == expected
 
     expire_date = datetime.date(2023, 8, 1)
     option_asset = Asset("SPY", asset_type="option", expiration=expire_date, strike=100, right="CALL")
-    expected = tmpdir / "thetadata" / f"option_SPY_230801_100_CALL_1D_{datastyle}.parquet"
+    expected = tmpdir / "thetadata" / "option" / "1d" / datastyle / f"option_SPY_230801_100_CALL_1D_{datastyle}.parquet"
     assert thetadata_helper.build_cache_filename(option_asset, timespan, datastyle) == expected
 
     # Bad option asset with no expiration
@@ -427,8 +427,8 @@ def test_missing_dates():
     ],
 )
 def test_update_cache(mocker, tmpdir, df_all, df_cached, datastyle):
-    mocker.patch.object(thetadata_helper, "LUMIBOT_CACHE_FOLDER", tmpdir)
-    cache_file = Path(tmpdir / "thetadata" / f"stock_SPY_1D_{datastyle}.parquet")
+    mocker.patch.object(thetadata_helper, "LUMIBOT_CACHE_FOLDER", str(tmpdir))
+    cache_file = thetadata_helper.build_cache_filename(Asset("SPY"), "1D", datastyle)
     
     # Empty DataFrame of df_all, don't write cache file
     thetadata_helper.update_cache(cache_file, df_all, df_cached)
@@ -550,8 +550,9 @@ def test_get_price_data_invokes_remote_cache_manager(tmp_path, monkeypatch):
 )
 def test_load_data_from_cache(mocker, tmpdir, df_cached, datastyle):
     # Setup some basics
-    mocker.patch.object(thetadata_helper, "LUMIBOT_CACHE_FOLDER", tmpdir)
-    cache_file = Path(tmpdir / "thetadata" / f"stock_SPY_1D_{datastyle}.parquet")
+    mocker.patch.object(thetadata_helper, "LUMIBOT_CACHE_FOLDER", str(tmpdir))
+    asset = Asset("SPY")
+    cache_file = thetadata_helper.build_cache_filename(asset, "1D", datastyle)
 
     # No cache file should return None (not raise)
     assert thetadata_helper.load_cache(cache_file) is None
@@ -1371,8 +1372,8 @@ class TestThetaDataChainsCaching:
 
         # CLEAR CACHE to ensure first call downloads fresh data
         # This prevents cache pollution from previous tests in the suite
-        # Chains are stored in: LUMIBOT_CACHE_FOLDER / "thetadata" / "option_chains"
-        chain_folder = Path(LUMIBOT_CACHE_FOLDER) / "thetadata" / "option_chains"
+        # Chains are stored in: LUMIBOT_CACHE_FOLDER / "thetadata" / "option" / "option_chains"
+        chain_folder = Path(LUMIBOT_CACHE_FOLDER) / "thetadata" / "option" / "option_chains"
         if chain_folder.exists():
             # Delete all AAPL chain cache files
             for cache_file in chain_folder.glob("AAPL_*.parquet"):
@@ -1407,6 +1408,46 @@ class TestThetaDataChainsCaching:
         assert time2 < time1 * 0.1, f"Cache not working: time1={time1:.2f}s, time2={time2:.2f}s (should be 10x faster)"
         print(f"✓ Cache speedup: {time1/time2:.1f}x faster ({time1:.2f}s -> {time2:.4f}s)")
 
+
+def test_finalize_day_frame_handles_dst_fallback():
+    tz = pytz.timezone("America/New_York")
+    utc = pytz.UTC
+    frame_index = pd.date_range(
+        end=tz.localize(datetime.datetime(2024, 10, 31, 16, 0)),
+        periods=5,
+        freq="D",
+    )
+    frame = pd.DataFrame(
+        {
+            "open": [100 + i for i in range(len(frame_index))],
+            "high": [101 + i for i in range(len(frame_index))],
+            "low": [99 + i for i in range(len(frame_index))],
+            "close": [100.5 + i for i in range(len(frame_index))],
+            "volume": [1000 + i for i in range(len(frame_index))],
+        },
+        index=frame_index,
+    )
+
+    data_source = ThetaDataBacktestingPandas(
+        datetime_start=utc.localize(datetime.datetime(2024, 10, 1)),
+        datetime_end=utc.localize(datetime.datetime(2024, 11, 5)),
+        username="user",
+        password="pass",
+        use_quote_data=False,
+    )
+
+    current_dt = utc.localize(datetime.datetime(2024, 11, 4, 13, 30))
+    result = data_source._finalize_day_frame(
+        frame,
+        current_dt,
+        requested_length=len(frame_index),
+        timeshift=None,
+        asset=Asset("TSLA"),
+    )
+
+    assert result is not None
+    assert len(result) == len(frame_index)
+
     def test_chains_strike_format(self):
         """Test strikes are floats (not integers) and properly converted."""
         username = os.environ.get("THETADATA_USERNAME")

{lumibot-4.2.1 → lumibot-4.2.4}/tests/test_thetadata_pandas_verification.py

@@ -44,7 +44,7 @@ def count_cache_files():
     cache_dir = get_cache_dir()
     if not cache_dir.exists():
         return 0
-    return len(list(cache_dir.glob("*.parquet")))
+    return sum(1 for _ in cache_dir.rglob("*.parquet"))
 
 
 class WeeklyMomentumOptionsStrategy(Strategy):