Use snapshot prices for IB dry runs

Author: Pigbibi

application/execution_service.py

@@ -13,10 +13,26 @@
 import pandas as pd
 
 
-def get_market_prices(ib, symbols, *, fetch_quote_snapshots):
+def get_market_prices(
+    ib,
+    symbols,
+    *,
+    fetch_quote_snapshots,
+    dry_run_only: bool = False,
+    snapshot_price_fallbacks: dict[str, float] | None = None,
+):
     """Fetch market prices for multiple symbols in one pass."""
     quotes = fetch_quote_snapshots(ib, symbols)
-    return {symbol: quote.last_price for symbol, quote in quotes.items()}
+    prices = {symbol: quote.last_price for symbol, quote in quotes.items()}
+    if dry_run_only and snapshot_price_fallbacks:
+        for symbol in symbols:
+            normalized = str(symbol).strip().upper()
+            if normalized in prices:
+                continue
+            fallback_price = snapshot_price_fallbacks.get(normalized)
+            if fallback_price and float(fallback_price) > 0:
+                prices[normalized] = float(fallback_price)
+    return prices
 
 
 def check_order_submitted(report, *, translator):
@@ -364,7 +380,18 @@ def execute_rebalance(
     if strategy_symbols:
         all_symbols = all_symbols & set(strategy_symbols)
 
-    prices = get_market_prices(ib, all_symbols, fetch_quote_snapshots=fetch_quote_snapshots)
+    snapshot_price_fallbacks = {
+        str(symbol).strip().upper(): float(price)
+        for symbol, price in dict(signal_metadata.get("dry_run_price_fallbacks") or {}).items()
+        if price is not None
+    }
+    prices = get_market_prices(
+        ib,
+        all_symbols,
+        fetch_quote_snapshots=fetch_quote_snapshots,
+        dry_run_only=dry_run_only,
+        snapshot_price_fallbacks=snapshot_price_fallbacks,
+    )
 
     current_mv = {}
     for symbol in all_symbols:

strategy_runtime.py

@@ -247,6 +247,10 @@ def _evaluate_feature_snapshot_strategy(
                 },
             )
             return StrategyEvaluationResult(decision=decision, metadata=metadata)
+        snapshot_close_map = self._build_snapshot_close_map(
+            feature_snapshot,
+            managed_symbols=managed_symbols,
+        )
         metadata = {
             "strategy_profile": self.profile,
             "feature_snapshot_path": self.runtime_settings.feature_snapshot_path,
@@ -256,11 +260,42 @@ def _evaluate_feature_snapshot_strategy(
             "dry_run_only": self.runtime_settings.dry_run_only,
             "trade_date": run_as_of.date().isoformat(),
             "managed_symbols": managed_symbols,
+            "dry_run_price_fallbacks": snapshot_close_map,
             "status_icon": self.status_icon,
             **guard_metadata,
         }
         return StrategyEvaluationResult(decision=decision, metadata=metadata)
 
+    def _build_snapshot_close_map(
+        self,
+        feature_snapshot,
+        *,
+        managed_symbols: tuple[str, ...],
+    ) -> dict[str, float]:
+        if not managed_symbols:
+            return {}
+        try:
+            frame = pd.DataFrame(feature_snapshot)
+        except Exception:
+            return {}
+        if frame.empty or "symbol" not in frame.columns or "close" not in frame.columns:
+            return {}
+        frame = frame.copy()
+        frame["symbol"] = frame["symbol"].astype(str).str.strip().str.upper()
+        frame = frame[frame["symbol"].isin({str(symbol).strip().upper() for symbol in managed_symbols})]
+        if frame.empty:
+            return {}
+        close_series = pd.to_numeric(frame["close"], errors="coerce")
+        frame = frame.assign(close_numeric=close_series)
+        frame = frame[frame["close_numeric"].notna() & frame["close_numeric"].gt(0)]
+        if frame.empty:
+            return {}
+        deduped = frame.drop_duplicates(subset=["symbol"], keep="last")
+        return {
+            str(row["symbol"]): float(row["close_numeric"])
+            for _, row in deduped.iterrows()
+        }
+
     def _extract_managed_symbols(
         self,
         feature_snapshot,

tests/test_execution_service.py

@@ -364,3 +364,45 @@ def accountValues(self):
     assert summary["no_op_reason"] == "insufficient_buying_power:VOO"
     assert summary["skipped_reasons"] == ["insufficient_buying_power:VOO"]
     assert "failed insufficient_buying_power:VOO" in trade_logs[-1]
+
+
+def test_execute_rebalance_uses_snapshot_prices_for_dry_run_when_quotes_missing(tmp_path):
+    class FakeIB:
+        def openTrades(self):
+            return []
+
+        def fills(self):
+            return []
+
+        def accountValues(self):
+            return [SimpleNamespace(tag="AvailableFunds", currency="USD", value="5000")]
+
+    trade_logs, summary = execute_rebalance(
+        FakeIB(),
+        {"VOO": 0.6, "BOXX": 0.4},
+        {},
+        {"equity": 1000.0, "buying_power": 1000.0},
+        fetch_quote_snapshots=lambda *_args, **_kwargs: {},
+        submit_order_intent=lambda *_args, **_kwargs: None,
+        order_intent_cls=OrderIntent,
+        translator=translate,
+        strategy_symbols=["VOO", "BOXX"],
+        strategy_profile="tech_pullback_cash_buffer",
+        signal_metadata={
+            "trade_date": "2026-04-01",
+            "snapshot_as_of": "2026-03-31",
+            "dry_run_price_fallbacks": {"VOO": 100.0, "BOXX": 100.0},
+        },
+        dry_run_only=True,
+        cash_reserve_ratio=0.0,
+        rebalance_threshold_ratio=0.02,
+        limit_buy_premium=1.005,
+        sell_settle_delay_sec=0,
+        execution_lock_dir=tmp_path,
+        return_summary=True,
+    )
+
+    assert summary["execution_status"] == "executed"
+    assert len(summary["orders_submitted"]) == 2
+    assert any(log.startswith("DRY_RUN buy VOO") for log in trade_logs)
+    assert any(log.startswith("DRY_RUN buy BOXX") for log in trade_logs)

tests/test_snapshot_strategy_runtime.py

@@ -253,3 +253,58 @@ def test_global_etf_rotation_keeps_default_cash_reserve(strategy_module_factory)
     )
 
     assert module.CASH_RESERVE_RATIO == pytest.approx(0.03)
+
+
+def test_compute_signals_exposes_dry_run_price_fallbacks(strategy_module_factory, tmp_path):
+    pytest.importorskip("pandas")
+
+    snapshot_path = tmp_path / "snapshot.csv"
+    config_path = tmp_path / "tech_pullback_cash_buffer.json"
+    snapshot_path.write_text(
+        "\n".join(
+            [
+                "as_of,symbol,sector,close,adv20_usd,history_days,mom_6_1,mom_12_1,sma20_gap,sma50_gap,sma200_gap,ma50_over_ma200,vol_63,maxdd_126,breakout_252,dist_63_high,dist_126_high,rebound_20,base_eligible",
+                "2026-03-31,QQQ,benchmark,500,1000000000,400,0.20,0.30,0.03,0.05,0.08,0.04,0.22,-0.12,-0.01,-0.03,-0.05,0.04,false",
+                "2026-03-31,BOXX,defense,101,20000000,400,0.02,0.04,0.00,0.00,0.01,0.00,0.03,-0.01,0.00,-0.01,-0.01,0.00,false",
+                "2026-03-31,AAPL,Information Technology,200,150000000,400,0.20,0.35,0.03,0.05,0.10,0.05,0.18,-0.08,-0.01,-0.03,-0.05,0.05,true",
+                "2026-03-31,MSFT,Information Technology,350,150000000,400,0.18,0.33,0.03,0.05,0.09,0.04,0.17,-0.09,-0.02,-0.04,-0.06,0.04,true",
+            ]
+        ),
+        encoding="utf-8",
+    )
+    config_path.write_text(
+        json.dumps(
+            {
+                "name": "tech_pullback_cash_buffer",
+                "family": "tech_heavy_pullback",
+                "branch_role": "cash-buffered parallel branch",
+                "benchmark_symbol": "QQQ",
+                "holdings_count": 2,
+                "single_name_cap": 0.5,
+                "sector_cap": 1.0,
+                "hold_bonus": 0.0,
+                "min_adv20_usd": 1.0,
+                "normalization": "universe_cross_sectional",
+                "score_template": "balanced_pullback",
+                "sector_whitelist": ["Information Technology"],
+                "breadth_thresholds": {"soft": 0.55, "hard": 0.35},
+                "exposures": {"risk_on": 1.0, "soft_defense": 1.0, "hard_defense": 0.0},
+                "execution_cash_reserve_ratio": 0.0,
+                "residual_proxy": "simple_excess_return_vs_QQQ",
+            }
+        ),
+        encoding="utf-8",
+    )
+    _write_cash_buffer_manifest(snapshot_path, config_path, snapshot_as_of="2026-03-31")
+
+    module = strategy_module_factory(
+        STRATEGY_PROFILE="tech_pullback_cash_buffer",
+        IBKR_FEATURE_SNAPSHOT_PATH=str(snapshot_path),
+        IBKR_FEATURE_SNAPSHOT_MANIFEST_PATH=str(Path(f"{snapshot_path}.manifest.json")),
+        IBKR_STRATEGY_CONFIG_PATH=str(config_path),
+        IBKR_RUN_AS_OF_DATE="2026-04-01",
+    )
+    result = module.compute_signals(None, set())
+
+    assert result[4]["dry_run_price_fallbacks"]["BOXX"] == pytest.approx(101.0)
+    assert result[4]["dry_run_price_fallbacks"]["AAPL"] == pytest.approx(200.0)