lumibot 4.1.1__tar.gz → 4.1.3__tar.gz

{lumibot-4.1.1 → lumibot-4.1.3}/MANIFEST.in

@@ -1,2 +1 @@
 recursive-include lumibot/resources *
-include ThetaTerminal.jar

{lumibot-4.1.1/lumibot.egg-info → lumibot-4.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: lumibot
-Version: 4.1.1
+Version: 4.1.3
 Summary: Backtesting and Trading Library, Made by Lumiwealth
 Home-page: https://github.com/Lumiwealth/lumibot
 Author: Robert Grzesik
@@ -51,6 +51,17 @@ Requires-Dist: schwab-py>=1.5.0
 Requires-Dist: Flask>=2.3
 Requires-Dist: free-proxy
 Requires-Dist: requests-oauthlib
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 [![CI Status](https://github.com/Lumiwealth/lumibot/actions/workflows/cicd.yaml/badge.svg?branch=dev)](https://github.com/Lumiwealth/lumibot/actions/workflows/cicd.yaml)
 [![Coverage](https://raw.githubusercontent.com/Lumiwealth/lumibot/badge/coverage.svg)](https://github.com/Lumiwealth/lumibot/actions/workflows/cicd.yaml)

{lumibot-4.1.1 → lumibot-4.1.3}/lumibot/strategies/_strategy.py

@@ -1264,9 +1264,24 @@ class _Strategy:
         if show_indicators is None:
             show_indicators = SHOW_INDICATORS
 
-        # Auto-select datasource from environment variable if None
-        if datasource_class is None:
-            from lumibot.credentials import BACKTESTING_DATA_SOURCE
+        from lumibot.credentials import BACKTESTING_DATA_SOURCE as _DEFAULT_BACKTESTING_DATA_SOURCE
+
+        # Determine whether an environment override exists. When BACKTESTING_DATA_SOURCE
+        # is set (and not blank/\"none\"), it should take precedence even if a
+        # datasource_class argument was provided.
+        env_override_raw = os.environ.get("BACKTESTING_DATA_SOURCE")
+        env_override_name = None
+
+        if env_override_raw is not None:
+            trimmed = env_override_raw.strip()
+            if trimmed and trimmed.lower() != "none":
+                env_override_name = trimmed.lower()
+        elif datasource_class is None:
+            # No override provided and no class in code – fall back to the default
+            # configured in credentials (ThetaData unless the project overrides it).
+            env_override_name = _DEFAULT_BACKTESTING_DATA_SOURCE.lower()
+
+        if env_override_name is not None:
             from lumibot.backtesting import (
                 PolygonDataBacktesting,
                 ThetaDataBacktesting,
@@ -1285,18 +1300,24 @@ class _Strategy:
                 "databento": DataBentoDataBacktesting,
             }
 
-            datasource_name = BACKTESTING_DATA_SOURCE.lower()
-            if datasource_name not in datasource_map:
+            if env_override_name not in datasource_map:
+                label = env_override_raw or _DEFAULT_BACKTESTING_DATA_SOURCE
                 raise ValueError(
-                    f"Unknown BACKTESTING_DATA_SOURCE: '{BACKTESTING_DATA_SOURCE}'. "
+                    f"Unknown BACKTESTING_DATA_SOURCE: '{label}'. "
                     f"Valid options: {list(datasource_map.keys())}"
                 )
 
-            datasource_class = datasource_map[datasource_name]
+            datasource_class = datasource_map[env_override_name]
+            label = env_override_raw or _DEFAULT_BACKTESTING_DATA_SOURCE
             get_logger(__name__).info(colored(
-                f"Auto-selected backtesting data source from BACKTESTING_DATA_SOURCE env var: {BACKTESTING_DATA_SOURCE}",
+                f"Using BACKTESTING_DATA_SOURCE setting for backtest data: {label}",
                 "green"
             ))
+        elif datasource_class is None:
+            raise ValueError(
+                "No backtesting data source provided. Set BACKTESTING_DATA_SOURCE in the environment "
+                "or pass datasource_class when calling backtest()."
+            )
 
         # Make sure polygon_api_key is set if using PolygonDataBacktesting
         polygon_api_key = polygon_api_key if polygon_api_key is not None else POLYGON_API_KEY

{lumibot-4.1.1 → lumibot-4.1.3}/lumibot/tools/databento_helper.py

@@ -593,13 +593,29 @@ def _filter_front_month_rows_pandas(
     if df.empty or "symbol" not in df.columns or schedule is None:
         return df
 
+    index_tz = getattr(df.index, "tz", None)
+
+    def _align(ts: datetime | pd.Timestamp | None) -> pd.Timestamp | None:
+        if ts is None:
+            return None
+        ts_pd = pd.Timestamp(ts)
+        if index_tz is None:
+            return ts_pd.tz_localize(None) if ts_pd.tz is not None else ts_pd
+        if ts_pd.tz is None:
+            ts_pd = ts_pd.tz_localize(index_tz)
+        else:
+            ts_pd = ts_pd.tz_convert(index_tz)
+        return ts_pd
+
     mask = pd.Series(False, index=df.index)
     for symbol, start_dt, end_dt in schedule:
         cond = df["symbol"] == symbol
-        if start_dt is not None:
-            cond &= df.index >= start_dt
-        if end_dt is not None:
-            cond &= df.index < end_dt
+        start_aligned = _align(start_dt)
+        end_aligned = _align(end_dt)
+        if start_aligned is not None:
+            cond &= df.index >= start_aligned
+        if end_aligned is not None:
+            cond &= df.index < end_aligned
         mask |= cond
 
     filtered = df.loc[mask]
@@ -783,15 +799,22 @@ def get_price_data_from_databento(
     start_naive = start.replace(tzinfo=None) if start.tzinfo is not None else start
     end_naive = end.replace(tzinfo=None) if end.tzinfo is not None else end
 
-    if asset.asset_type == Asset.AssetType.CONT_FUTURE:
+    roll_asset = asset
+    if asset.asset_type == Asset.AssetType.FUTURE and not asset.expiration:
+        roll_asset = Asset(asset.symbol, Asset.AssetType.CONT_FUTURE)
+
+    if roll_asset.asset_type == Asset.AssetType.CONT_FUTURE:
         schedule_start = start
-        symbols = databento_roll.resolve_symbols_for_range(asset, schedule_start, end)
-        front_symbol = databento_roll.resolve_symbol_for_datetime(asset, reference_date or start)
+        symbols = databento_roll.resolve_symbols_for_range(roll_asset, schedule_start, end)
+        front_symbol = databento_roll.resolve_symbol_for_datetime(roll_asset, reference_date or start)
         if front_symbol not in symbols:
             symbols.insert(0, front_symbol)
     else:
         schedule_start = start
-        front_symbol = _format_futures_symbol_for_databento(asset)
+        front_symbol = _format_futures_symbol_for_databento(
+            asset,
+            reference_date=reference_date or start,
+        )
         symbols = [front_symbol]
 
     # Ensure multiplier is populated using the first contract.
@@ -904,7 +927,7 @@ def get_price_data_from_databento(
         return definition
 
     schedule = databento_roll.build_roll_schedule(
-        asset,
+        roll_asset,
         schedule_start,
         end,
         definition_provider=get_definition,

{lumibot-4.1.1 → lumibot-4.1.3}/lumibot/tools/databento_helper_polars.py

@@ -929,10 +929,14 @@ def get_price_data_from_databento_polars(
     start_naive = start.replace(tzinfo=None) if start.tzinfo is not None else start
     end_naive = end.replace(tzinfo=None) if end.tzinfo is not None else end
 
-    if asset.asset_type == Asset.AssetType.CONT_FUTURE:
+    roll_asset = asset
+    if asset.asset_type == Asset.AssetType.FUTURE and not asset.expiration:
+        roll_asset = Asset(asset.symbol, Asset.AssetType.CONT_FUTURE)
+
+    if roll_asset.asset_type == Asset.AssetType.CONT_FUTURE:
         schedule_start = start
-        symbols_to_fetch = databento_roll.resolve_symbols_for_range(asset, schedule_start, end)
-        front_symbol = databento_roll.resolve_symbol_for_datetime(asset, reference_date or start)
+        symbols_to_fetch = databento_roll.resolve_symbols_for_range(roll_asset, schedule_start, end)
+        front_symbol = databento_roll.resolve_symbol_for_datetime(roll_asset, reference_date or start)
         if front_symbol not in symbols_to_fetch:
             symbols_to_fetch.insert(0, front_symbol)
         logger.info(
@@ -941,7 +945,10 @@ def get_price_data_from_databento_polars(
         )
     else:
         schedule_start = start
-        front_symbol = _format_futures_symbol_for_databento(asset)
+        front_symbol = _format_futures_symbol_for_databento(
+            asset,
+            reference_date=reference_date or start,
+        )
         symbols_to_fetch = [front_symbol]
 
     # Fetch and cache futures multiplier from DataBento if needed (after symbol resolution)
@@ -1092,7 +1099,7 @@ def get_price_data_from_databento_polars(
         return definition
 
     schedule = databento_roll.build_roll_schedule(
-        asset,
+        roll_asset,
         schedule_start,
         end,
         definition_provider=get_definition,

{lumibot-4.1.1 → lumibot-4.1.3}/lumibot/tools/thetadata_helper.py

@@ -498,20 +498,25 @@ def start_theta_data_client(username: str, password: str):
         logger.info("ThetaTerminal.jar not found, copying from lumibot package...")
         import shutil as shutil_copy
 
-        # Find the bundled jar file in the lumibot package
-        lumibot_jar = Path(__file__).parent.parent.parent / "ThetaTerminal.jar"
+        package_root = Path(__file__).resolve().parent.parent
+        candidate_paths = [
+            package_root / "resources" / "ThetaTerminal.jar",
+            package_root.parent / "ThetaTerminal.jar",  # legacy location fallback
+        ]
 
-        if lumibot_jar.exists():
-            logger.info(f"Copying ThetaTerminal.jar from {lumibot_jar} to {jar_file}")
-            shutil_copy.copy2(lumibot_jar, jar_file)
-            logger.info(f"Successfully copied ThetaTerminal.jar to {jar_file}")
-        else:
+        lumibot_jar = next((path for path in candidate_paths if path.exists()), None)
+
+        if lumibot_jar is None:
             raise FileNotFoundError(
-                f"ThetaTerminal.jar not found at {lumibot_jar}. "
-                f"Please ensure ThetaTerminal.jar is included in the lumibot package, "
-                f"or manually place it at {jar_file}"
+                "ThetaTerminal.jar not bundled with lumibot installation. "
+                f"Searched: {', '.join(str(path) for path in candidate_paths)}. "
+                f"Please reinstall lumibot or manually place the jar at {jar_file}"
             )
 
+        logger.info(f"Copying ThetaTerminal.jar from {lumibot_jar} to {jar_file}")
+        shutil_copy.copy2(lumibot_jar, jar_file)
+        logger.info(f"Successfully copied ThetaTerminal.jar to {jar_file}")
+
     if not jar_file.exists():
         raise FileNotFoundError(f"ThetaTerminal.jar not found at {jar_file}")
 

{lumibot-4.1.1 → lumibot-4.1.3/lumibot.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: lumibot
-Version: 4.1.1
+Version: 4.1.3
 Summary: Backtesting and Trading Library, Made by Lumiwealth
 Home-page: https://github.com/Lumiwealth/lumibot
 Author: Robert Grzesik
@@ -51,6 +51,17 @@ Requires-Dist: schwab-py>=1.5.0
 Requires-Dist: Flask>=2.3
 Requires-Dist: free-proxy
 Requires-Dist: requests-oauthlib
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 [![CI Status](https://github.com/Lumiwealth/lumibot/actions/workflows/cicd.yaml/badge.svg?branch=dev)](https://github.com/Lumiwealth/lumibot/actions/workflows/cicd.yaml)
 [![Coverage](https://raw.githubusercontent.com/Lumiwealth/lumibot/badge/coverage.svg)](https://github.com/Lumiwealth/lumibot/actions/workflows/cicd.yaml)

{lumibot-4.1.1 → lumibot-4.1.3}/lumibot.egg-info/SOURCES.txt

@@ -1,7 +1,6 @@
 LICENSE
 MANIFEST.in
 README.md
-ThetaTerminal.jar
 pyproject.toml
 setup.cfg
 setup.py
@@ -102,6 +101,7 @@ lumibot/example_strategies/stock_momentum.py
 lumibot/example_strategies/stock_oco.py
 lumibot/example_strategies/strangle.py
 lumibot/example_strategies/test_broker_functions.py
+lumibot/resources/ThetaTerminal.jar
 lumibot/resources/conf.yaml
 lumibot/strategies/__init__.py
 lumibot/strategies/_strategy.py
@@ -248,6 +248,7 @@ tests/backtest/test_crypto_cash_regressions.py
 tests/backtest/test_daily_data_timestamp_comparison.py
 tests/backtest/test_databento.py
 tests/backtest/test_databento_comprehensive_trading.py
+tests/backtest/test_databento_parity.py
 tests/backtest/test_debug_avg_fill_price.py
 tests/backtest/test_dividends.py
 tests/backtest/test_example_strategies.py

{lumibot-4.1.1 → lumibot-4.1.3}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setuptools.setup(
     name="lumibot",
-    version="4.1.1",
+    version="4.1.3",
     author="Robert Grzesik",
     author_email="rob@lumiwealth.com",
     description="Backtesting and Trading Library, Made by Lumiwealth",
@@ -14,7 +14,7 @@ setuptools.setup(
     url="https://github.com/Lumiwealth/lumibot",
     packages=setuptools.find_packages(),
     license="MIT",  # Add license argument
-    include_package_data=True, 
+    include_package_data=True,
     install_requires=[
         "polygon-api-client>=1.13.3",
         "alpaca-py>=0.42.0",
@@ -61,7 +61,9 @@ setuptools.setup(
         "free-proxy",
         "requests-oauthlib",
     ],
-    data_files=[("", ["ThetaTerminal.jar"])],
+    package_data={
+        "lumibot": ["resources/ThetaTerminal.jar"],
+    },
     classifiers=[
         "Programming Language :: Python :: 3",
         "Operating System :: OS Independent",

{lumibot-4.1.1 → lumibot-4.1.3}/tests/backtest/test_databento_comprehensive_trading.py

@@ -215,6 +215,14 @@ class TestDatabentoComprehensiveTrading:
 
         print(f"\n  Instruments traded: {list(trades_by_instrument.keys())}")
 
+        snapshots_by_symbol = {}
+        for snap in strat.snapshots:
+            symbol = snap.get("current_asset")
+            if symbol:
+                snapshots_by_symbol.setdefault(symbol, []).append(snap)
+
+        fee_amount = float(fee.flat_fee)
+
         # Analyze each instrument's trades
         for symbol, trades in trades_by_instrument.items():
             print(f"\n" + "-"*80)
@@ -249,16 +257,45 @@ class TestDatabentoComprehensiveTrading:
                 assert actual_asset.multiplier == expected_multiplier, \
                     f"{symbol} asset.multiplier should be {expected_multiplier}, got {actual_asset.multiplier}"
 
-                # For now, just verify cash is reasonable (not testing exact margin since
-                # we may have P&L from previous trades affecting cash)
-                print(f"\nCASH STATE:")
-                print(f"  Cash after entry: ${entry['cash_after']:,.2f}")
-                print(f"  (Note: Cash includes P&L from previous trades)")
-
-                # Verify portfolio value is reasonable (shouldn't be massively negative)
-                portfolio_after = entry['portfolio_after']
-                assert portfolio_after > 50000, \
-                    f"{symbol} portfolio value seems wrong after entry: ${portfolio_after:,.2f}"
+                symbol_snapshots = snapshots_by_symbol.get(symbol, [])
+                entry_snapshot = next((s for s in symbol_snapshots if s.get("phase") == "BUY"), None)
+                sell_snapshot = next((s for s in symbol_snapshots if s.get("phase") == "SELL"), None)
+                hold_snapshots = [s for s in symbol_snapshots if s.get("phase") == "HOLD"]
+
+                assert entry_snapshot is not None, f"No entry snapshot recorded for {symbol}"
+                assert sell_snapshot is not None, f"No sell snapshot recorded for {symbol}"
+
+                cash_before_entry = float(entry_snapshot["cash"])
+                entry_cash_after = float(entry["cash_after"])
+                margin_deposit = cash_before_entry - entry_cash_after - fee_amount
+                expected_margin_total = expected_margin * float(entry["quantity"])
+
+                print(f"\nCASH / MARGIN STATE:")
+                print(f"  Cash before entry: ${cash_before_entry:,.2f}")
+                print(f"  Cash after entry: ${entry_cash_after:,.2f}")
+                print(f"  Margin captured: ${margin_deposit:,.2f} (expected ${expected_margin_total:,.2f})")
+                assert pytest.approx(margin_deposit, abs=0.01) == expected_margin_total, (
+                    f"{symbol} margin mismatch: expected ${expected_margin_total:,.2f}, "
+                    f"got ${margin_deposit:,.2f}"
+                )
+
+                # Verify mark-to-market during hold period is exact
+                for snap in hold_snapshots:
+                    price = snap.get("price")
+                    if price is None:
+                        continue
+                    unrealized = (price - entry["price"]) * float(entry["quantity"]) * expected_multiplier
+                    expected_portfolio = entry_cash_after + margin_deposit + unrealized
+                    assert pytest.approx(expected_portfolio, abs=0.01) == float(snap["portfolio"]), (
+                        f"{symbol} mark-to-market mismatch at {snap['datetime']}: "
+                        f"expected ${expected_portfolio:,.2f}, got ${snap['portfolio']:,.2f}"
+                    )
+
+                # Snapshot immediately before exit should have identical cash to post-entry state
+                assert pytest.approx(float(sell_snapshot["cash"]), abs=0.01) == entry_cash_after, (
+                    f"{symbol} cash prior to exit changed unexpectedly: "
+                    f"{sell_snapshot['cash']} vs {entry_cash_after}"
+                )
 
             if len(exits) > 0 and len(entries) > 0:
                 entry = entries[0]
@@ -283,79 +320,21 @@ class TestDatabentoComprehensiveTrading:
                 print(f"  Price change: ${price_change:.2f}")
                 print(f"  Expected P&L: ${expected_pnl:.2f} (change × qty × {expected_multiplier})")
 
-                # Verify final portfolio reflects P&L
-                # Note: We can't verify exact final cash without knowing all previous trades,
-                # but we can verify the P&L calculation makes sense
-                assert abs(expected_pnl) < 100000, \
-                    f"{symbol} P&L seems unrealistic: {expected_pnl}"
-
-                # CRITICAL: Verify portfolio value changed by approximately expected P&L
-                # (can't be exact due to fees and previous trades, but should be in ballpark)
-                entry_portfolio = entry['portfolio_after']
-                exit_portfolio = exit_trade['portfolio_after']
-                portfolio_change = exit_portfolio - entry_portfolio
-
-                # Portfolio change should be close to expected P&L (within margin for fees/rounding)
-                pnl_diff = abs(portfolio_change - expected_pnl)
-                print(f"  Portfolio change: ${portfolio_change:.2f}")
-                print(f"  Difference from expected: ${pnl_diff:.2f}")
-
-                # Allow generous tolerance for fees, rounding, and concurrent trades
-                # For small P&L, allow larger percentage; for large P&L, allow smaller percentage
-                tolerance = max(abs(expected_pnl) * 0.5, 500)
-                # For this comprehensive test with multiple concurrent trades, just verify it's reasonable
-                # (exact match is tested in simpler single-trade tests)
-                if pnl_diff < tolerance:
-                    print(f"  ✓ Portfolio change matches expected P&L within tolerance")
-                else:
-                    print(f"  ⚠ Portfolio change differs (may be due to concurrent trades)")
-
-        # CRITICAL: Verify unrealized P&L during HOLD periods
-        # This catches bugs in portfolio value calculation (multiplier applied to unrealized P&L)
-        print(f"\n" + "-"*80)
-        print("VERIFYING UNREALIZED P&L DURING HOLD PERIODS")
-        print("-"*80)
-
-        for symbol in trades_by_instrument.keys():
-            # Find snapshots where we're holding this position
-            holding_snapshots = [s for s in strat.snapshots if s['position_qty'] > 0 and s.get('current_asset') == symbol]
-
-            if len(holding_snapshots) >= 2:
-                # Check a couple of snapshots during the hold
-                snap = holding_snapshots[len(holding_snapshots)//2]  # middle of hold period
-
-                # Get the entry trade for this position
-                entries = [t for t in trades_by_instrument[symbol] if "buy" in str(t["side"]).lower()]
-                if entries:
-                    entry = entries[0]
-                    entry_price = entry['price']
-                    quantity = entry['quantity']
-                    current_price = snap['price']
-                    expected_mult = CONTRACT_SPECS.get(symbol, {}).get("multiplier", 1)
-                    expected_margin = CONTRACT_SPECS.get(symbol, {}).get("margin", 1000)
-
-                    # Calculate expected portfolio value
-                    cash = snap['cash']
-                    margin_tied_up = quantity * expected_margin
-                    unrealized_pnl = (current_price - entry_price) * quantity * expected_mult
-                    expected_portfolio = cash + margin_tied_up + unrealized_pnl
-                    actual_portfolio = snap['portfolio']
-
-                    print(f"\n{symbol} during HOLD (snapshot {strat.snapshots.index(snap)}):")
-                    print(f"  Entry: ${entry_price:.2f} × {quantity} contracts")
-                    print(f"  Current: ${current_price:.2f}")
-                    print(f"  Cash: ${cash:,.2f}")
-                    print(f"  Margin: ${margin_tied_up:,.2f}")
-                    print(f"  Unrealized P&L: ${unrealized_pnl:,.2f} = (${current_price:.2f} - ${entry_price:.2f}) × {quantity} × {expected_mult}")
-                    print(f"  Expected portfolio: ${expected_portfolio:,.2f}")
-                    print(f"  Actual portfolio: ${actual_portfolio:,.2f}")
-                    print(f"  Difference: ${abs(actual_portfolio - expected_portfolio):,.2f}")
-
-                    # This tolerance should catch multiplier bugs (5x error would be huge)
-                    tolerance = max(abs(expected_portfolio) * 0.02, 100)  # 2% or $100
-                    assert abs(actual_portfolio - expected_portfolio) < tolerance, \
-                        f"{symbol} portfolio value incorrect during hold: expected ${expected_portfolio:,.2f}, got ${actual_portfolio:,.2f}"
-                    print(f"  ✓ Portfolio value matches expected (within ${tolerance:.2f})")
+                cash_before_entry = float(snapshots_by_symbol[symbol][0]["cash"])
+                expected_cash_after_exit = (
+                    cash_before_entry
+                    - fee_amount  # entry fee
+                    - fee_amount  # exit fee
+                    + expected_pnl
+                )
+                print(f"\nCASH RECONCILIATION:")
+                print(f"  Expected cash after exit: ${expected_cash_after_exit:,.2f}")
+                actual_cash_after_exit = float(exit_trade["cash_after"])
+                print(f"  Actual cash after exit:   ${actual_cash_after_exit:,.2f}")
+                assert pytest.approx(expected_cash_after_exit, abs=0.01) == actual_cash_after_exit, (
+                    f"{symbol} cash after exit mismatch: expected ${expected_cash_after_exit:,.2f}, "
+                    f"got ${actual_cash_after_exit:,.2f}"
+                )
 
         print(f"\n" + "="*80)
         print("✓ ALL INSTRUMENTS VERIFIED")

lumibot-4.1.3/tests/backtest/test_databento_parity.py

@@ -0,0 +1,103 @@
+"""Parity checks between DataBento pandas and polars backends."""
+
+import shutil
+from datetime import datetime
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+import pytest
+import pytz
+
+from lumibot.backtesting.databento_backtesting import DataBentoDataBacktesting as DataBentoPandas
+from lumibot.data_sources.databento_data_polars_backtesting import DataBentoDataPolarsBacktesting
+from lumibot.entities import Asset
+from lumibot.credentials import DATABENTO_CONFIG
+from lumibot.tools import databento_helper, databento_helper_polars
+
+DATABENTO_API_KEY = DATABENTO_CONFIG.get("API_KEY")
+
+
+def _clear_databento_caches():
+    for cache_dir in (
+        databento_helper.LUMIBOT_DATABENTO_CACHE_FOLDER,
+        databento_helper_polars.LUMIBOT_DATABENTO_CACHE_FOLDER,
+    ):
+        path = Path(cache_dir)
+        if path.exists():
+            shutil.rmtree(path)
+
+
+@pytest.mark.apitest
+@pytest.mark.skipif(
+    not DATABENTO_API_KEY or DATABENTO_API_KEY == '<your key here>',
+    reason="This test requires a Databento API key",
+)
+def test_databento_price_parity():
+    """Ensure pandas and polars backends deliver identical prices."""
+
+    _clear_databento_caches()
+
+    tz = pytz.timezone("America/New_York")
+    start = tz.localize(datetime(2025, 9, 15, 0, 0))
+    end = tz.localize(datetime(2025, 9, 29, 23, 59))
+    asset = Asset("MES", asset_type=Asset.AssetType.CONT_FUTURE)
+
+    pandas_ds = DataBentoPandas(
+        datetime_start=start,
+        datetime_end=end,
+        api_key=DATABENTO_API_KEY,
+        show_progress_bar=False,
+    )
+    polars_ds = DataBentoDataPolarsBacktesting(
+        datetime_start=start,
+        datetime_end=end,
+        api_key=DATABENTO_API_KEY,
+        show_progress_bar=False,
+    )
+
+    # Prime caches
+    pandas_bars = pandas_ds.get_historical_prices(asset, 500, timestep="minute").df.sort_index()
+    polars_bars = polars_ds.get_historical_prices(asset, 500, timestep="minute").df.sort_index()
+
+    candidate_columns = ["open", "high", "low", "close", "volume", "vwap"]
+    common_columns = [col for col in candidate_columns if col in pandas_bars.columns and col in polars_bars.columns]
+    assert common_columns, "No shared OHLCV columns between pandas and polars DataFrames"
+
+    aligned_pandas = pandas_bars[common_columns].copy()
+    aligned_polars = polars_bars[common_columns].copy()
+
+    for col in common_columns:
+        dtype_left = aligned_pandas[col].dtype
+        dtype_right = aligned_polars[col].dtype
+        if dtype_left != dtype_right:
+            target_dtype = np.promote_types(dtype_left, dtype_right)
+            aligned_pandas[col] = aligned_pandas[col].astype(target_dtype)
+            aligned_polars[col] = aligned_polars[col].astype(target_dtype)
+
+    pd.testing.assert_frame_equal(
+        aligned_pandas,
+        aligned_polars,
+        check_exact=True,
+        check_index_type=True,
+        check_column_type=True,
+    )
+
+    checkpoints = [
+        (0, 0),
+        (3, 40),
+        (4, 0),
+        (7, 35),
+        (11, 5),
+        (14, 5),
+    ]
+
+    for hour, minute in checkpoints:
+        current_dt = tz.localize(datetime(2025, 9, 15, hour, minute))
+        pandas_ds._datetime = current_dt
+        polars_ds._datetime = current_dt
+        pandas_price = pandas_ds.get_last_price(asset)
+        polars_price = polars_ds.get_last_price(asset)
+        assert pandas_price == polars_price, (
+            f"Mismatch at {current_dt}: pandas={pandas_price}, polars={polars_price}"
+        )