lumibot 4.1.2__tar.gz → 4.1.3__tar.gz

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

@@ -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 → 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.2 → 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.2 → 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.2 → lumibot-4.1.3/lumibot.egg-info}/PKG-INFO

@@ -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 → 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.2",
+    version="4.1.3",
     author="Robert Grzesik",
     author_email="rob@lumiwealth.com",
     description="Backtesting and Trading Library, Made by Lumiwealth",

{lumibot-4.1.2 → 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.2 → lumibot-4.1.3}/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}"
         )

{lumibot-4.1.2 → lumibot-4.1.3}/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