lumibot 4.1.2__py3-none-any.whl → 4.1.3__py3-none-any.whl

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/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/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.2.dist-info → lumibot-4.1.3.dist-info}/METADATA

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

{lumibot-4.1.2.dist-info → lumibot-4.1.3.dist-info}/RECORD

@@ -159,7 +159,7 @@ lumibot/example_strategies/__pycache__/test_broker_functions.cpython-312-pytest-
 lumibot/resources/ThetaTerminal.jar,sha256=K6GeeFcN8-gvyL2x5iq5pzD79KfPJvMK8iiezi3TmNQ,11834389
 lumibot/resources/conf.yaml,sha256=rjB9-10JP7saZ_edjX5bQDGfuc3amOQTUUUr-UiMpNA,597
 lumibot/strategies/__init__.py,sha256=jEZ95K5hG0f595EXYKWwL2_UsnWWk5Pug361PK2My2E,79
-lumibot/strategies/_strategy.py,sha256=QCrrZQzTZ0GjsNyNNxHNI3WaNZ98yvxT-E0dbOBETMg,109685
+lumibot/strategies/_strategy.py,sha256=KI4nhQX4qrr0Dp4G0uN-njn03y3xoJDM762O-ru41Vg,110745
 lumibot/strategies/session_manager.py,sha256=Nze6UYNSPlCsf-tyHvtFqUeL44WSNHjwsKrIepvsyCY,12956
 lumibot/strategies/strategy.py,sha256=i-jAt2a1DXSiKT1gMQ5vXkbLb29x9vAFZl9zehbfJ1s,169301
 lumibot/strategies/strategy_executor.py,sha256=IrHwDOu5s3gG65dz7FL-0kllWy7COci7JFyB4iiPUrg,70801
@@ -172,8 +172,8 @@ lumibot/tools/alpaca_helpers.py,sha256=nhBS-sv28lZfIQ85szC9El8VHLrCw5a5KbsGOOEjm
 lumibot/tools/bitunix_helpers.py,sha256=-UzrN3w_Y-Ckvhl7ZBoAcx7sgb6tH0KcpVph1Ovm3gw,25780
 lumibot/tools/black_scholes.py,sha256=TBjJuDTudvqsbwqSb7-zb4gXsJBCStQFaym8xvePAjw,25428
 lumibot/tools/ccxt_data_store.py,sha256=VXLSs0sWcwjRPZzbuEeVPS-3V6D10YnYMfIyoTPTG0U,21225
-lumibot/tools/databento_helper.py,sha256=cbeMTrJOTu2E_Z9s021V_RGa4xrQ1LYI03SRi29pnQA,42976
-lumibot/tools/databento_helper_polars.py,sha256=yQN4nIWg-WNXKoW8s1x8GUoq3rtmf6-NWNPnjFSZz2Q,53153
+lumibot/tools/databento_helper.py,sha256=XBCAxc_GJ_oOTnHIsc5XSsRGmwymTqosLUbaKpIwaBw,43807
+lumibot/tools/databento_helper_polars.py,sha256=4Nx4rUC-zY7zF25J__HRf5PXyZQGSGuX7zfkllvuWIo,53418
 lumibot/tools/databento_roll.py,sha256=48HAw3h6OngCK4UTl9ifpjo-ki8qmB6OoJUrHp0gRmE,6767
 lumibot/tools/debugers.py,sha256=ga6npFsS9cpKtTXaygh9t2_txCElg3bfzfeqDBvSL8k,485
 lumibot/tools/decorators.py,sha256=gokLv6s37C1cnbnFSVOUc4RaVJ5aMTU2C344Vvi3ycs,2275
@@ -225,7 +225,7 @@ lumibot/trading_builtins/safe_list.py,sha256=IIjZOHSiZYK25A4WBts0oJaZNOJDsjZL65M
 lumibot/trading_builtins/__pycache__/__init__.cpython-312.pyc,sha256=ksqDHG5HzxBeh3sDNn2NjEhYtj3dI6TvuQoe03VAItg,345
 lumibot/trading_builtins/__pycache__/custom_stream.cpython-312.pyc,sha256=w9EEoPd4LTBKmS8x6x-umicO1GwzaHlZnAv7MC2A78o,7397
 lumibot/trading_builtins/__pycache__/safe_list.cpython-312.pyc,sha256=2MQnqSCnMHHVu_gMK-3xBVSdHFyhxGR7_UrNdOvb4So,4875
-lumibot-4.1.2.dist-info/licenses/LICENSE,sha256=fYhGIyxjyNXACgpNQS3xxpxDOaVOWRVxZMCRbsDv8k0,35130
+lumibot-4.1.3.dist-info/licenses/LICENSE,sha256=fYhGIyxjyNXACgpNQS3xxpxDOaVOWRVxZMCRbsDv8k0,35130
 tests/__init__.py,sha256=3-VoT-nAuqMfwufd4ceN6fXaHl_zCfDCSXJOTp1ywYQ,393
 tests/conftest.py,sha256=UBw_2fx7r6TZPKus2b1Qxrzmd4bg8EEBnX1vCHUuSVA,3311
 tests/fixtures.py,sha256=wOHQsh1SGHnXe_PGi6kDWI30CS_Righi7Ig7vwSEKT4,9082
@@ -244,7 +244,7 @@ tests/test_backtesting_broker.py,sha256=rxZGH5cgiWLmNGdI3k9fti3Fp9IOSohq8xD2E3L2
 tests/test_backtesting_broker_await_close.py,sha256=WbehY7E4Qet3_Mo7lpfgjmhtI9pnJPIt9mkFI15Dzho,7545
 tests/test_backtesting_broker_time_advance.py,sha256=FCv0nKG8BQlEjNft7kmQYm9M2CsLIZ0b7mWCllOHQxc,6378
 tests/test_backtesting_crypto_cash_unit.py,sha256=4EO9jVajdZNV0M7zSyp4gpR_msZFoM4x5tb-6g-mHO8,11399
-tests/test_backtesting_data_source_env.py,sha256=Y36G2f0z_BsYkNA7zxKXwlbyQxKDXYbLDV_E4qjEem0,10671
+tests/test_backtesting_data_source_env.py,sha256=MQaKNSbRzl5yXqFkMbBkt3C63stQtJJ8RE4jypVEv1U,12114
 tests/test_backtesting_flow_control.py,sha256=pBqW-fa-HnZq0apUBltalGMM-vNJ_2A5W2SoJzMK8Mg,7208
 tests/test_backtesting_multileg_unit.py,sha256=h1DPfVuYXXx-uq6KtUjr6_nasZuXPm_5gFat1XxCKIo,6456
 tests/test_backtesting_quiet_logs_complete.py,sha256=x-GfOiqkiUu8pYKCzB0UUacn13Nx_cPRth7_jmPY2Y8,14155
@@ -270,7 +270,7 @@ tests/test_databento_auto_expiry_integration.py,sha256=uPAyYTMTzEqppUUZx99G8pvnv
 tests/test_databento_backtesting.py,sha256=LqcuHgjivmHIcEcCjZNSPDdD7epCwdaKtj6Q6Q4KTF0,20671
 tests/test_databento_backtesting_polars.py,sha256=V9Z7-WG2TNKpHQVF5vGJSIdgUsuhJwlopZV66FREWA0,8097
 tests/test_databento_data.py,sha256=HakjDileGpicQc_OXeX7l8ncIDn3FtxP8ymKA6TQp8o,18860
-tests/test_databento_helper.py,sha256=C2FRkD3341FFHc09bObEYYN7eqUsO9aewyaLX9hCdvU,43465
+tests/test_databento_helper.py,sha256=Oeojl4xTZi37JewuX0n-7ML8EQcLTbl5Jc4ugtQrYb8,43611
 tests/test_databento_live.py,sha256=tbg2C9cyW45OYY7dKYlPMNZpgsN_sjs4yk1GR23OL6o,15648
 tests/test_databento_timezone_fixes.py,sha256=NsfND7yTdKH2ddiYYhO6kU3m41V7se7C4_zTvqKOGv0,11562
 tests/test_drift_rebalancer.py,sha256=AUuEd3WIunfx3gwVdLVtq8jOHlz65UeqpO4adY1xfcs,105289
@@ -337,13 +337,13 @@ tests/backtest/test_buy_hold_quiet_logs_full_run.py,sha256=LDiR8wsEwIASPnO_bUMid
 tests/backtest/test_crypto_cash_regressions.py,sha256=-f0wjb-9nXpggS30N4zomYl098Qu-tfvfWwhlkoxPMM,6077
 tests/backtest/test_daily_data_timestamp_comparison.py,sha256=DeMLH0hwl0zEybJF0YTyBgfO8p96DGLahiBCwVQKjA4,35910
 tests/backtest/test_databento.py,sha256=L7UIN0IjxdVzE65ujBvsoKyQhY4KHTctIOeOeWvVNBY,7485
-tests/backtest/test_databento_comprehensive_trading.py,sha256=M7M2YHVkYRi5xBXifUESCnX5BFdtUDXy-HAhgazBAC4,23615
-tests/backtest/test_databento_parity.py,sha256=bG10kIJlkLnXfPaEYMVhaf8D5V5Gf-qoyB9PW-H8JzM,2553
+tests/backtest/test_databento_comprehensive_trading.py,sha256=ZqZm6yOc9qAPSpjPLRIE2EZTr3jQPCtlmeKSLN9vOQw,21990
+tests/backtest/test_databento_parity.py,sha256=YGF3L7dv4CMfJISj1KrObBWXneK3xwjp7Iw4mVtR32k,3481
 tests/backtest/test_debug_avg_fill_price.py,sha256=W4pgvCkAwmqlK82yzlw7u-s8VXe-dIQjPu-BVQkwJvg,3520
 tests/backtest/test_dividends.py,sha256=tDEnK4IcqHPHYPXAfUlApEBOf-iMROSl3aCap0BX1nI,9970
 tests/backtest/test_example_strategies.py,sha256=mSRRONtKdd7x0DUiuqCZD3YXLiPS8kAGn5wT1f_gDlk,15482
 tests/backtest/test_failing_backtest.py,sha256=jBkm_3Yq-TrzezAQM7XEAn3424lzG6Mu5agnTJQCo6E,5460
-tests/backtest/test_futures_edge_cases.py,sha256=87j1WQ3ywE1FkusZGlW9IXFlqFhf776EXHd-yQmySZY,15422
+tests/backtest/test_futures_edge_cases.py,sha256=If97ybqmaGw3lxK8hMSNFGaRM3ovDphNdyCqLhGmFrE,18314
 tests/backtest/test_futures_single_trade.py,sha256=seGe-mOkoFnCY58HT-iaWktPo76-WG0xgxPkOiL6BOg,10838
 tests/backtest/test_futures_ultra_simple.py,sha256=UWGhuhwALCpez-yJxmbke5pfW6vHLDsHbsezwezU934,6875
 tests/backtest/test_index_data_verification.py,sha256=oCM_xRMylyDkUS0uDXCyj4KVKs_GG24lcqCvQq1Exvw,13737
@@ -356,7 +356,7 @@ tests/backtest/test_thetadata.py,sha256=xWYfC9C4EhbMDb29qyZWHO3sSWaLIPzzvcMbHCt5
 tests/backtest/test_thetadata_comprehensive.py,sha256=-gN3xLJcJtlB-k4vlaK82DCZDGDmr0LNZZDzn-aN3l4,26120
 tests/backtest/test_thetadata_vs_polygon.py,sha256=dZqsrOx3u3cz-1onIO6o5BDRjI1ey7U9vIkZupfXoig,22831
 tests/backtest/test_yahoo.py,sha256=uHb9aK3uHYEvA7MI_y1dbKm7mjHrErlxU7TJOgVdzs8,1966
-lumibot-4.1.2.dist-info/METADATA,sha256=45LvQ6tGhCYieVoXNPDspLGbhfj7JccZ1xZFzTilsHs,11721
-lumibot-4.1.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lumibot-4.1.2.dist-info/top_level.txt,sha256=otUnUjDFVASauEDiTiAzNgMyqQ1B6jjS3QqqP-WSx38,14
-lumibot-4.1.2.dist-info/RECORD,,
+lumibot-4.1.3.dist-info/METADATA,sha256=bqCXhktv5-RaCGiktkddUfpmjDUfBKhzS5josA6A1Sk,11721
+lumibot-4.1.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lumibot-4.1.3.dist-info/top_level.txt,sha256=otUnUjDFVASauEDiTiAzNgMyqQ1B6jjS3QqqP-WSx38,14
+lumibot-4.1.3.dist-info/RECORD,,

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")

tests/backtest/test_databento_parity.py

@@ -1,9 +1,10 @@
 """Parity checks between DataBento pandas and polars backends."""
 
 import shutil
-from pathlib import Path
 from datetime import datetime
+from pathlib import Path
 
+import numpy as np
 import pandas as pd
 import pytest
 import pytz
@@ -56,10 +57,31 @@ def test_databento_price_parity():
     )
 
     # Prime caches
-    pandas_bars = pandas_ds.get_historical_prices(asset, 500, timestep="minute").df
-    polars_bars = polars_ds.get_historical_prices(asset, 500, timestep="minute").df
+    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"
 
-    pd.testing.assert_frame_equal(polars_bars, pandas_bars)
+    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),
@@ -76,6 +98,6 @@ def test_databento_price_parity():
         polars_ds._datetime = current_dt
         pandas_price = pandas_ds.get_last_price(asset)
         polars_price = polars_ds.get_last_price(asset)
-        assert pandas_price == pytest.approx(polars_price), (
+        assert pandas_price == polars_price, (
             f"Mismatch at {current_dt}: pandas={pandas_price}, polars={polars_price}"
         )

tests/backtest/test_futures_edge_cases.py

@@ -31,6 +31,8 @@ DATABENTO_API_KEY = DATABENTO_CONFIG.get("API_KEY")
 # Contract specs
 MES_MULTIPLIER = 5
 ES_MULTIPLIER = 50
+MES_MARGIN = 1300
+ES_MARGIN = 13000
 
 
 def _clear_polars_cache():
@@ -211,6 +213,8 @@ class TestFuturesEdgeCases:
 
         broker = BacktestingBroker(data_source=data_source)
         fee = TradingFee(flat_fee=0.50)
+        fee_amount = float(fee.flat_fee)
+        fee_amount = float(fee.flat_fee)
 
         strat = ShortSellingStrategy(
             broker=broker,
@@ -252,7 +256,7 @@ class TestFuturesEdgeCases:
             assert trade['multiplier'] == MES_MULTIPLIER, \
                 f"MES multiplier should be {MES_MULTIPLIER}, got {trade['multiplier']}"
 
-        # If we have both entry and exit, verify P&L
+        # If we have both entry and exit, verify P&L and cash bookkeeping exactly
         if len(strat.trades) >= 2:
             entry = strat.trades[0]  # Sell to open
             exit_trade = strat.trades[1]  # Buy to cover
@@ -261,10 +265,19 @@ class TestFuturesEdgeCases:
             print("P&L VERIFICATION (SHORT TRADE)")
             print("-"*80)
 
-            # For short: P&L = (Entry - Exit) × Qty × Multiplier (inverted!)
+            entry_snapshot = strat.snapshots[0]
+            holding_snapshots = [s for s in strat.snapshots if s['position_qty'] < 0]
+            assert holding_snapshots, "No holding snapshots recorded for short position"
+            sell_snapshot = holding_snapshots[-1]  # still short immediately before closing
+            final_snapshot = next((s for s in strat.snapshots if s['position_qty'] == 0 and s['iteration'] > sell_snapshot['iteration']), strat.snapshots[-1])
+
+            margin_deposit = float(entry_snapshot['cash']) - float(entry['cash_after']) - fee_amount
+            print(f"  Margin captured: ${margin_deposit:.2f}")
+            assert pytest.approx(margin_deposit, abs=0.01) == 1300.0, f"Expected $1,300 margin, got ${margin_deposit:.2f}"
+
             entry_price = entry['price']
             exit_price = exit_trade['price']
-            price_change = entry_price - exit_price  # Inverted for short
+            price_change = entry_price - exit_price  # inverted for short
             expected_pnl = price_change * MES_MULTIPLIER
 
             print(f"  Entry (sell): ${entry_price:.2f}")
@@ -272,23 +285,34 @@ class TestFuturesEdgeCases:
             print(f"  Price change (entry - exit): ${price_change:.2f}")
             print(f"  Expected P&L: ${expected_pnl:.2f} (inverted for short)")
 
-            # Verify final cash
-            starting_cash = 100000
-            total_fees = 1.00  # 2 × $0.50
-            expected_final_cash = starting_cash + expected_pnl - total_fees
-
-            # Get final snapshot cash
-            final_cash = strat.snapshots[-1]['cash']
-            cash_diff = abs(expected_final_cash - final_cash)
-
-            print(f"\n  Starting cash: ${starting_cash:,.2f}")
-            print(f"  Expected final cash: ${expected_final_cash:,.2f}")
-            print(f"  Actual final cash: ${final_cash:,.2f}")
-            print(f"  Difference: ${cash_diff:.2f}")
-
-            # Allow tolerance for timing/fill differences
-            assert cash_diff < 150, f"Cash difference too large: ${cash_diff:.2f}"
-            print(f"\n✓ PASS: Short selling P&L is correct")
+            # Mark-to-market validation during the hold window
+            for snap in holding_snapshots[:-1]:
+                current_price = snap['price']
+                if current_price is None:
+                    continue
+                unrealized = (entry_price - current_price) * MES_MULTIPLIER
+                expected_portfolio = float(entry['cash_after']) + margin_deposit + unrealized
+                assert pytest.approx(expected_portfolio, abs=0.01) == float(snap['portfolio']), (
+                    f"Short unrealized P&L mismatch at {snap['datetime']}: "
+                    f"expected ${expected_portfolio:,.2f}, got ${snap['portfolio']:,.2f}"
+                )
+
+            assert pytest.approx(float(sell_snapshot['cash']), abs=0.01) == float(entry['cash_after']), \
+                "Cash should not drift while holding the short position"
+
+            # Final cash should equal initial cash minus fees plus realized P&L
+            starting_cash = float(entry_snapshot['cash'])
+            expected_final_cash = starting_cash - 2 * fee_amount + expected_pnl
+            print(f"\n  Expected final cash: ${expected_final_cash:,.2f}")
+            actual_final_cash = float(final_snapshot['cash'])
+            print(f"  Actual final cash:   ${actual_final_cash:,.2f}")
+            assert pytest.approx(expected_final_cash, abs=0.01) == actual_final_cash, \
+                f"Final cash mismatch: expected ${expected_final_cash:,.2f}, got ${actual_final_cash:,.2f}"
+
+            assert pytest.approx(expected_final_cash, abs=0.01) == float(exit_trade['cash_after']), \
+                "Cash reported in exit trade callback should match final ledger"
+
+            print(f"\n✓ PASS: Short selling P&L and cash bookkeeping are exact")
 
         print("\n" + "="*80)
         print("✓ SHORT SELLING TEST PASSED")
@@ -383,54 +407,63 @@ class TestFuturesEdgeCases:
             assert trade['multiplier'] == ES_MULTIPLIER, \
                 f"ES multiplier should be {ES_MULTIPLIER}, got {trade['multiplier']}"
 
-        # Calculate expected P&L for each instrument
+        fee_amount = float(fee.flat_fee)
+        mes_entry = mes_trades[0]
+        mes_exit = mes_trades[1]
+        es_entry = es_trades[0]
+        es_exit = es_trades[1]
+
+        mes_entry_snapshot = next(s for s in strat.snapshots if s['datetime'] == mes_entry['datetime'])
+        es_entry_snapshot = next(s for s in strat.snapshots if s['datetime'] == es_entry['datetime'])
+
+        mes_margin = float(mes_entry_snapshot['cash']) - float(mes_entry['cash_after']) - fee_amount
+        es_margin = float(es_entry_snapshot['cash']) - float(es_entry['cash_after']) - fee_amount
+
+        assert pytest.approx(mes_margin, abs=0.01) == MES_MARGIN, \
+            f"MES margin should be ${MES_MARGIN}, got ${mes_margin:.2f}"
+        assert pytest.approx(es_margin, abs=0.01) == ES_MARGIN, \
+            f"ES margin should be ${ES_MARGIN}, got ${es_margin:.2f}"
+
         print("\n" + "-"*80)
-        print("P&L VERIFICATION")
+        print("MARK-TO-MARKET VERIFICATION")
         print("-"*80)
 
-        # MES P&L
-        mes_entry = mes_trades[0]
-        mes_exit = mes_trades[1]
-        mes_pnl = (mes_exit['price'] - mes_entry['price']) * MES_MULTIPLIER
+        for snap in strat.snapshots:
+            expected_portfolio = float(snap['cash'])
 
-        print(f"\nMES:")
-        print(f"  Entry: ${mes_entry['price']:.2f}")
-        print(f"  Exit: ${mes_exit['price']:.2f}")
-        print(f"  P&L: ${mes_pnl:.2f}")
+            if snap['mes_qty'] != 0 and snap.get('mes_price') is not None:
+                expected_portfolio += abs(snap['mes_qty']) * MES_MARGIN
+                expected_portfolio += (snap['mes_price'] - mes_entry['price']) * snap['mes_qty'] * MES_MULTIPLIER
 
-        # ES P&L
-        es_entry = es_trades[0]
-        es_exit = es_trades[1]
-        es_pnl = (es_exit['price'] - es_entry['price']) * ES_MULTIPLIER
+            if snap['es_qty'] != 0 and snap.get('es_price') is not None:
+                expected_portfolio += abs(snap['es_qty']) * ES_MARGIN
+                expected_portfolio += (snap['es_price'] - es_entry['price']) * snap['es_qty'] * ES_MULTIPLIER
 
-        print(f"\nES:")
-        print(f"  Entry: ${es_entry['price']:.2f}")
-        print(f"  Exit: ${es_exit['price']:.2f}")
-        print(f"  P&L: ${es_pnl:.2f}")
+            assert pytest.approx(expected_portfolio, abs=0.01) == float(snap['portfolio']), (
+                f"Portfolio mismatch at {snap['datetime']}: "
+                f"expected ${expected_portfolio:,.2f}, got ${snap['portfolio']:,.2f}"
+            )
 
-        # Total P&L
+        mes_pnl = (mes_exit['price'] - mes_entry['price']) * MES_MULTIPLIER
+        es_pnl = (es_exit['price'] - es_entry['price']) * ES_MULTIPLIER
         total_pnl = mes_pnl + es_pnl
-        total_fees = 4.00  # 4 trades × $0.50 each (assuming $0.50 per side)
-
-        print(f"\nTotal:")
-        print(f"  Combined P&L: ${total_pnl:.2f}")
-        print(f"  Total fees: ${total_fees:.2f}")
-        print(f"  Net P&L: ${total_pnl - total_fees:.2f}")
-
-        # Verify final cash
-        starting_cash = 100000
-        expected_final_cash = starting_cash + total_pnl - total_fees
-        final_cash = strat.snapshots[-1]['cash']
-        cash_diff = abs(expected_final_cash - final_cash)
-
-        print(f"\n  Starting cash: ${starting_cash:,.2f}")
-        print(f"  Expected final cash: ${expected_final_cash:,.2f}")
-        print(f"  Actual final cash: ${final_cash:,.2f}")
-        print(f"  Difference: ${cash_diff:.2f}")
-
-        # Allow tolerance
-        assert cash_diff < 200, f"Cash difference too large: ${cash_diff:.2f}"
-        print(f"\n✓ PASS: Multiple simultaneous positions tracked correctly")
+        total_fees = 4 * fee_amount
+
+        starting_cash = float(strat.snapshots[0]['cash'])
+        expected_final_cash = starting_cash - total_fees + total_pnl
+        final_cash = float(strat.snapshots[-1]['cash'])
+
+        print(f"\nTotal realised P&L: ${total_pnl:.2f}")
+        print(f"Total fees: ${total_fees:.2f}")
+        print(f"Expected final cash: ${expected_final_cash:,.2f}")
+        print(f"Actual final cash:   ${final_cash:,.2f}")
+
+        assert pytest.approx(expected_final_cash, abs=0.01) == final_cash, \
+            f"Final cash mismatch: expected ${expected_final_cash:,.2f}, got ${final_cash:,.2f}"
+        assert pytest.approx(expected_final_cash, abs=0.01) == float(es_exit['cash_after']), \
+            "Exit trade cash should match ledger final cash"
+
+        print(f"\n✓ PASS: Multiple simultaneous positions tracked with exact accounting")
 
         # Verify we had both positions at the same time (iteration 3-4)
         snapshot_with_both = None

tests/test_backtesting_data_source_env.py

@@ -98,7 +98,7 @@ class TestBacktestingDataSourceEnv:
             )
 
             # Verify the log message shows polygon was selected
-            assert any("Auto-selected backtesting data source from BACKTESTING_DATA_SOURCE env var: polygon" in record.message
+            assert any("Using BACKTESTING_DATA_SOURCE setting for backtest data: polygon" in record.message
                       for record in caplog.records)
 
     def test_auto_select_thetadata_case_insensitive(self, clean_environment, restore_theta_credentials, caplog):
@@ -130,7 +130,7 @@ class TestBacktestingDataSourceEnv:
                 pass
 
             # Verify the log message shows thetadata was selected OR check for ThetaData error
-            thetadata_selected = any("Auto-selected backtesting data source from BACKTESTING_DATA_SOURCE env var: THETADATA" in record.message
+            thetadata_selected = any("Using BACKTESTING_DATA_SOURCE setting for backtest data: THETADATA" in record.message
                                     for record in caplog.records)
             thetadata_attempted = any("Cannot connect to Theta Data" in record.message or "ThetaData" in record.message
                                      for record in caplog.records)
@@ -183,8 +183,11 @@ class TestBacktestingDataSourceEnv:
                     show_indicators=False,
                 )
 
-    def test_explicit_datasource_overrides_env(self, clean_environment, restore_theta_credentials, caplog):
-        """Test that explicit datasource_class overrides BACKTESTING_DATA_SOURCE env var."""
+    def test_env_override_wins_over_explicit_datasource(self, clean_environment, restore_theta_credentials, caplog):
+        """Test that BACKTESTING_DATA_SOURCE env var takes precedence over explicit datasource_class."""
+        import logging
+        caplog.set_level(logging.INFO, logger='lumibot.strategies._strategy')
+
         with patch.dict(os.environ, {'BACKTESTING_DATA_SOURCE': 'polygon'}):
             # Re-import credentials to pick up env change
             from importlib import reload
@@ -205,9 +208,36 @@ class TestBacktestingDataSourceEnv:
                 show_progress_bar=False,
             )
 
-            # Verify the auto-select message was NOT logged (explicit datasource was used)
-            assert not any("Auto-selected backtesting data source" in record.message
-                          for record in caplog.records)
+            # Verify the env override message was logged (env var wins)
+            assert any("Using BACKTESTING_DATA_SOURCE setting for backtest data: polygon" in record.message
+                       for record in caplog.records)
+
+    def test_explicit_datasource_used_when_env_none(self, clean_environment, restore_theta_credentials, caplog):
+        """Test that setting BACKTESTING_DATA_SOURCE to 'none' defers to the explicit datasource_class."""
+        import logging
+        caplog.set_level(logging.INFO, logger='lumibot.strategies._strategy')
+
+        with patch.dict(os.environ, {'BACKTESTING_DATA_SOURCE': 'none'}):
+            from importlib import reload
+            import lumibot.credentials
+            reload(lumibot.credentials)
+
+            backtesting_start = datetime(2023, 1, 1)
+            backtesting_end = datetime(2023, 1, 10)  # Shorter backtest for speed
+
+            SimpleTestStrategy.run_backtest(
+                YahooDataBacktesting,
+                backtesting_start=backtesting_start,
+                backtesting_end=backtesting_end,
+                show_plot=False,
+                show_tearsheet=False,
+                show_indicators=False,
+                show_progress_bar=False,
+            )
+
+            # Confirm no override occurred
+            assert not any("Using BACKTESTING_DATA_SOURCE setting for backtest data" in record.message
+                           for record in caplog.records)
 
     def test_default_thetadata_when_no_env_set(self, clean_environment, restore_theta_credentials, caplog):
         """Test that ThetaData is the default when BACKTESTING_DATA_SOURCE is not set."""
@@ -240,9 +270,13 @@ class TestBacktestingDataSourceEnv:
                 # Expected to fail with test credentials - that's okay
                 pass
 
-            # Verify ThetaData was attempted (no auto-select message since it's the default)
-            assert any("Cannot connect to Theta Data" in record.message or "ThetaData" in record.message
-                      for record in caplog.records), "ThetaData was not used as default"
+            # Verify ThetaData was attempted (look for override message or Theta-specific logs)
+            assert any(
+                "Using BACKTESTING_DATA_SOURCE setting for backtest data: ThetaData" in record.message
+                or "Cannot connect to Theta Data" in record.message
+                or "ThetaData" in record.message
+                for record in caplog.records
+            ), "ThetaData was not used as default"
 
 
 if __name__ == "__main__":

tests/test_databento_helper.py

@@ -49,7 +49,12 @@ class TestDataBentoHelper(unittest.TestCase):
         self.assertRegex(result, r"ES[FGHJKMNQUVXZ]\d", "Should auto-resolve to contract format like ESZ5")
         
         # Test specific contract with expiration (March 2025 = H25)
-        result = databento_helper._format_futures_symbol_for_databento(self.test_asset_future)
+        specific_future = Asset(
+            symbol="ES",
+            asset_type="future",
+            expiration=datetime(2025, 3, 15).date()
+        )
+        result = databento_helper._format_futures_symbol_for_databento(specific_future)
         self.assertEqual(result, "ESH25")  # March 2025 = H25
         
         # Test another month (December 2024 = Z24)