powerquant-cli 0.2.6__py3-none-any.whl

quant_core/app/backtest/schema.py

@@ -0,0 +1,477 @@
+"""Backtest Schema - BacktestConfig / 生命周期 / Equity Curve / Metrics / Result（T7）
+
+语义 SSOT：`app/backtest/SPEC.md`、T7 Task（2026-09-05 用户确认的 MVP
+指标口径）与 DECISIONS.md 2026-09-04。
+
+边界：
+- 全部领域结果深度不可变（frozen + tuple），集合顺序确定，重复读取幂等；
+- 随机技术 ID（uuid）不参与业务确定性比较，不进入指标；
+- 指标严格 Decimal，不把 float 引入领域结果，不静默 quantize；
+- MVP 不把 Fill 冒充完整策略交易：`trade_count` / `win_rate` 显式为 None，
+  limitations 以稳定机器可查 code 披露（无 CompletedTrade 账本）。
+"""
+
+from datetime import datetime
+from decimal import Decimal
+from enum import Enum
+
+from pydantic import BaseModel, ConfigDict, Field, computed_field, field_validator, model_validator
+
+from quant_core.app.backtest.legacy_result_schema import RebalancePlanSnapshot
+from quant_core.app.data.constants import BarFrequency
+from quant_core.app.data.schema.adjustment_schema import AdjustmentAnchorMode, AdjustmentType
+from quant_core.app.data.schema.trading_state_schema import validate_canonical_instrument_id
+from quant_core.app.order_execution.constants import ExecutionPolicy
+from quant_core.app.order_execution.domain.order_event import (
+    ExecutionAttempt,
+    Fill,
+    OrderTransition,
+)
+from quant_core.app.order_execution.domain.order_value import OrderSnapshot
+from quant_core.app.portfolio.ledger_schema import (
+    CashLedgerEntry,
+    ClosedTrade,
+    OrderReservationLedgerEntry,
+    PositionLotSnapshot,
+)
+from quant_core.app.portfolio.portfolio_schema import PortfolioSnapshot
+from quant_core.app.strategy.schema.portfolio_target import PortfolioDecision
+from quant_core.app.trading_runtime.runtime_schema import TraceEntry
+
+
+class BacktestStatus(str, Enum):
+    """BacktestRun 生命周期状态机
+
+    CREATED → DATA_CHECK → RUNNING → SETTLING → COMPLETED；
+    任意非终态阶段异常 → FAILED（终态，不可恢复）。
+    """
+
+    CREATED = "created"
+    DATA_CHECK = "data_check"
+    RUNNING = "running"
+    SETTLING = "settling"
+    COMPLETED = "completed"
+    FAILED = "failed"
+
+
+class BacktestDataRevision(BaseModel):
+    """回测实际验证通过的数据版本；revision 变化即形成新的缓存命名空间。"""
+
+    model_config = ConfigDict(frozen=True)
+
+    dataset: str
+    instrument_id: str
+    frequency: str | None = None
+    revision: str
+
+    @property
+    def cache_namespace(self) -> str:
+        frequency = self.frequency or "event"
+        return f"{self.dataset}:{self.instrument_id}:{frequency}:{self.revision}"
+
+
+class BarSourceMode(str, Enum):
+    NATIVE = "native"
+    AGGREGATED = "aggregated"
+
+
+class BacktestFrequencyPlan(BaseModel):
+    """回测观察与撮合频率及其唯一数据来源。"""
+
+    model_config = ConfigDict(frozen=True)
+
+    observation_frequency: BarFrequency
+    execution_frequency: BarFrequency
+    observation_source: BarSourceMode
+    execution_source: BarSourceMode
+
+
+class BacktestConfig(BaseModel):
+    """一次历史回测的配置（不可变；进入 Result 作为配置快照）"""
+
+    model_config = ConfigDict(frozen=True)
+
+    strategy_id: str = Field(..., min_length=1, description="本次回测执行的策略标识")
+    instrument_ids: tuple[str, ...] = Field(
+        ..., min_length=1, description="标的（Canonical，非空去重）"
+    )
+    frequency: BarFrequency = Field(..., description="Bar 频率")
+    execution_frequency: BarFrequency | None = Field(
+        default=None, description="撮合频率；为空时与观察频率一致"
+    )
+    start: datetime = Field(..., description="回测区间开始（含，timezone-aware）")
+    end: datetime = Field(..., description="回测区间结束（含，timezone-aware）")
+    initial_cash: Decimal = Field(..., gt=0, description="初始资金（Decimal，> 0）")
+    execution_policy: ExecutionPolicy = ExecutionPolicy.CURRENT_BAR_CLOSE
+    auto_switch_order_value: bool = False
+    strategy_adjustment_type: AdjustmentType = Field(
+        default=AdjustmentType.PRE, description="Strategy 观察价格口径"
+    )
+    strategy_anchor_mode: AdjustmentAnchorMode = Field(
+        default=AdjustmentAnchorMode.DECISION_TIME, description="Strategy 复权锚点策略"
+    )
+    trading_days_per_year: Decimal = Field(
+        default=Decimal("252"), gt=0, description="年化交易日数（指标参数，> 0）"
+    )
+    annual_risk_free_rate: Decimal = Field(
+        default=Decimal("0"), ge=0, description="年化无风险收益率（>= 0）"
+    )
+
+    @field_validator("instrument_ids")
+    @classmethod
+    def _validate_instrument_ids(cls, ids: tuple[str, ...]) -> tuple[str, ...]:
+        for instrument_id in ids:
+            validate_canonical_instrument_id(instrument_id)
+        if len(set(ids)) != len(ids):
+            raise ValueError(f"instrument_ids 不允许重复：{ids}")
+        return tuple(sorted(ids))
+
+    @field_validator("strategy_id")
+    @classmethod
+    def _validate_strategy_id(cls, value: str) -> str:
+        if value != value.strip():
+            raise ValueError("strategy_id 不允许首尾空白")
+        return value
+
+    @field_validator("start", "end")
+    @classmethod
+    def _check_tz_aware(cls, value: datetime) -> datetime:
+        if value.tzinfo is None:
+            raise ValueError("BacktestConfig.start/end 必须 timezone-aware")
+        return value
+
+    @field_validator(
+        "initial_cash", "trading_days_per_year", "annual_risk_free_rate", mode="before"
+    )
+    @classmethod
+    def _reject_float(cls, value: object) -> object:
+        if isinstance(value, float):
+            raise ValueError("BacktestConfig 金额/参数必须使用 Decimal，禁止 float")
+        return value
+
+    @model_validator(mode="after")
+    def _check_range(self) -> "BacktestConfig":
+        if self.start > self.end:
+            raise ValueError(f"start {self.start} 必须不晚于 end {self.end}")
+        if (
+            self.strategy_adjustment_type is AdjustmentType.PRE
+            and self.strategy_anchor_mode is not AdjustmentAnchorMode.DECISION_TIME
+        ):
+            raise ValueError("历史回测 PRE 只允许 DECISION_TIME 动态锚点")
+        execution_frequency = self.execution_frequency or self.frequency
+        if (
+            self.execution_policy is ExecutionPolicy.DAILY_VWAP
+            and execution_frequency is not BarFrequency.D1
+        ):
+            raise ValueError("DAILY_VWAP 只支持日线撮合")
+        durations = {
+            BarFrequency.M1: 1,
+            BarFrequency.M5: 5,
+            BarFrequency.M15: 15,
+            BarFrequency.M30: 30,
+            BarFrequency.H1: 60,
+            BarFrequency.D1: 1440,
+            BarFrequency.W1: 10080,
+        }
+        if durations[execution_frequency] > durations[self.frequency]:
+            raise ValueError("撮合频率不得粗于策略观察频率")
+        return self
+
+
+class EquityPoint(BaseModel):
+    """权益曲线单点：(成功片 slice_time, portfolio_snapshot.total_value)"""
+
+    model_config = ConfigDict(frozen=True)
+
+    time: datetime = Field(..., description="片市场时间（timezone-aware）")
+    total_value: Decimal = Field(..., description="该片估值后的组合总值")
+
+    @field_validator("time")
+    @classmethod
+    def _check_tz(cls, value: datetime) -> datetime:
+        if value.tzinfo is None:
+            raise ValueError("EquityPoint.time 必须 timezone-aware")
+        return value
+
+    @field_validator("total_value", mode="before")
+    @classmethod
+    def _reject_float_value(cls, value: object) -> object:
+        if isinstance(value, float):
+            raise ValueError("EquityPoint.total_value 必须使用 Decimal，禁止 float")
+        return value
+
+
+class EquityCurve(BaseModel):
+    """权益曲线（每个成功 StepResult 恰好一个点；时间严格递增）"""
+
+    model_config = ConfigDict(frozen=True)
+
+    points: tuple[EquityPoint, ...] = Field(default_factory=tuple)
+
+    @field_validator("points")
+    @classmethod
+    def _check_strictly_increasing(cls, points: tuple[EquityPoint, ...]) -> tuple[EquityPoint, ...]:
+        for i in range(1, len(points)):
+            if points[i].time <= points[i - 1].time:
+                raise ValueError(
+                    f"EquityCurve 时间必须严格递增：{points[i - 1].time} -> {points[i].time}"
+                )
+        return points
+
+    @property
+    def last_value(self) -> Decimal | None:
+        """最终权益（空曲线为 None）"""
+        return self.points[-1].total_value if self.points else None
+
+
+class BacktestMetrics(BaseModel):
+    """回测基础指标（口径 SSOT：T7 Task Confirmed Decisions 2026-09-05）
+
+    - total_return = ending_equity / initial_cash - 1（空曲线为 None）
+    - annualized_return = (ending/initial) ** (tdpy/n_days) - 1；少于 2 个
+      观测交易日为 None
+    - max_drawdown = 相对历史峰值最大跌幅（非负；无回撤为 0）
+    - sharpe_ratio = mean(daily_returns - daily_rf) / sample_stddev(daily_returns)
+      * sqrt(tdpy)；少于 2 个日收益或样本标准差为 0 为 None
+    - gross_turnover_rate = 成交绝对金额合计 / 平均日末组合净值；费用不计入成交金额
+    - fill_count 精确统计 Fill 数量；trade_count / win_rate 显式 None
+      （Literal[None] 使「未建立 CompletedTrade 账本」在类型层机器可查）
+    """
+
+    model_config = ConfigDict(frozen=True)
+
+    total_return: Decimal | None = Field(default=None, description="累计收益率；空数据为 None")
+    annualized_return: Decimal | None = Field(
+        default=None, description="年化收益率；观测不足为 None"
+    )
+    max_drawdown: Decimal = Field(default=Decimal("0"), ge=0, description="最大回撤（非负）")
+    sharpe_ratio: Decimal | None = Field(default=None, description="Sharpe 比率；不可计算为 None")
+    fill_count: int = Field(default=0, ge=0, description="Fill 成交笔数（不等于完整交易）")
+    trade_count: int | None = Field(default=None, ge=0, description="ClosedTrade 数量")
+    win_rate: Decimal | None = Field(default=None, ge=0, le=1, description="盈利 ClosedTrade 占比")
+    profit_loss_ratio: Decimal | None = Field(
+        default=None, ge=0, description="平均盈利/平均亏损绝对值"
+    )
+    average_holding_days: Decimal | None = Field(default=None, ge=0, description="平均持有自然日")
+    gross_turnover_rate: Decimal | None = Field(
+        default=None,
+        ge=0,
+        description="成交绝对金额合计 / 平均日末组合净值；空曲线或分母为零时为 None",
+    )
+
+    @field_validator(
+        "total_return",
+        "annualized_return",
+        "max_drawdown",
+        "sharpe_ratio",
+        "win_rate",
+        "profit_loss_ratio",
+        "average_holding_days",
+        "gross_turnover_rate",
+        mode="before",
+    )
+    @classmethod
+    def _reject_float_metric(cls, value: object) -> object:
+        if isinstance(value, float):
+            raise ValueError("指标必须使用 Decimal，禁止 float")
+        return value
+
+
+class DecisionTrace(BaseModel):
+    """决策轨迹（append-only 聚合：只追加成功片的 TraceEntry，深度不可变）
+
+    时间轨迹不得倒退（同一时间片多条合法）；聚合自
+    RuntimeStepResult.trace_entries；Backtest 不复制 Runtime 单片业务顺序。
+    """
+
+    model_config = ConfigDict(frozen=True)
+
+    entries: tuple[TraceEntry, ...] = Field(default_factory=tuple)
+
+    @field_validator("entries")
+    @classmethod
+    def _check_non_decreasing(cls, entries: tuple[TraceEntry, ...]) -> tuple[TraceEntry, ...]:
+        for i in range(1, len(entries)):
+            if entries[i].event_time < entries[i - 1].event_time:
+                raise ValueError(
+                    f"DecisionTrace 时间不得倒退：{entries[i - 1].event_time} -> "
+                    f"{entries[i].event_time}（同一时间片多条合法）"
+                )
+        return entries
+
+    def appended(self, entries: tuple[TraceEntry, ...]) -> "DecisionTrace":
+        """返回追加了新条目的新实例（append-only：原实例不可变）"""
+        return DecisionTrace(entries=self.entries + tuple(entries))
+
+
+class ResultLimitation(str, Enum):
+    """结果能力限制的稳定机器可查 code（stable API，不得随意改值）"""
+
+    TRADE_COUNT_UNAVAILABLE = "TRADE_COUNT_UNAVAILABLE:NO_COMPLETED_TRADE_LEDGER"
+    WIN_RATE_UNAVAILABLE = "WIN_RATE_UNAVAILABLE:NO_COMPLETED_TRADE_LEDGER"
+    PRE_TAX_DIVIDEND = "PRE_TAX_DIVIDEND:NO_HOLDING_PERIOD_TAX"
+
+
+class BacktestResult(BaseModel):
+    """一次回测的最终结果（深度不可变；重复读取幂等且全等）
+
+    全部事实来自已成功提交的 RuntimeStepResult 与 Order Execution 公开
+    投影；不读取 Runtime / Portfolio / Execution 私有状态。
+
+    构造边界封闭（model_validator 校验，矛盾输入无法构造）：
+    - MVP 只表达实际可产出的 COMPLETED Result；FAILED 仅由
+      BacktestRun.status 表达；
+    - metrics.fill_count == len(fills)；
+    - started/ended_event_time 与 EquityCurve 首尾一致；空 Curve 对应
+      started/ended/final snapshot 均为 None，非空 Curve 对应均存在；
+    - final snapshot 的 as_of / total_value 与最后 EquityPoint 一致；
+    - limitations 只允许 ResultLimitation 权威 code，拒绝重复，按 Enum
+      定义顺序规范化，且必需的 CompletedTrade limitation 不得遗漏。
+    """
+
+    model_config = ConfigDict(frozen=True)
+
+    status: BacktestStatus = Field(..., description="最终状态（MVP 仅 COMPLETED）")
+    config: BacktestConfig = Field(..., description="配置快照")
+    data_revisions: tuple[BacktestDataRevision, ...] = Field(
+        default_factory=tuple,
+        description="复权/公司行动版本钉住；版本变化天然失效旧缓存",
+    )
+    started_event_time: datetime | None = Field(default=None, description="首个成功片时间")
+    ended_event_time: datetime | None = Field(default=None, description="最后成功片时间")
+    final_portfolio_snapshot: PortfolioSnapshot | None = Field(
+        default=None, description="最后成功片的组合投影（数据结束时持仓如实保留）"
+    )
+    order_snapshots: tuple[OrderSnapshot, ...] = Field(
+        default_factory=tuple, description="最终订单状态（含数据结束时仍有效的订单）"
+    )
+    # T4R R4 finding 4：SETTLING 阶段的结构化生命周期迁移（coarse PENDING
+    # DAY 单 EXPIRED_AT_BACKTEST_END）独立披露——不伪造成市场事件或成交，
+    # event_time = ended_event_time，为空 tuple 表示无到期发生
+    settling_order_updates: tuple[OrderTransition, ...] = Field(
+        default_factory=tuple,
+        description="回测终止阶段的结构化订单生命周期迁移（可审计；无则为空）",
+    )
+    fills: tuple[Fill, ...] = Field(default_factory=tuple, description="全部 Fill（成功片）")
+    position_lots: tuple[PositionLotSnapshot, ...] = Field(
+        default_factory=tuple, description="最终持仓批次投影（含已耗尽批次）"
+    )
+    cash_ledger_entries: tuple[CashLedgerEntry, ...] = Field(
+        default_factory=tuple, description="现金与应收账户的 append-only 流水"
+    )
+    reservation_ledger_entries: tuple[OrderReservationLedgerEntry, ...] = Field(
+        default_factory=tuple, description="订单现金与证券冻结的 append-only 流水"
+    )
+    closed_trades: tuple[ClosedTrade, ...] = Field(
+        default_factory=tuple, description="FIFO 开平配对事实"
+    )
+    execution_attempts: tuple[ExecutionAttempt, ...] = Field(
+        default_factory=tuple, description="全部撮合检查（成功片）"
+    )
+    equity_curve: EquityCurve = Field(..., description="权益曲线（每成功片一点）")
+    metrics: BacktestMetrics = Field(..., description="基础指标")
+    decision_trace: DecisionTrace = Field(..., description="决策轨迹（append-only）")
+    rebalance_plans: tuple[RebalancePlanSnapshot, ...] = ()  # 历史结果读取，不驱动新运行
+    portfolio_decisions: tuple[PortfolioDecision, ...] = ()
+
+    limitations: tuple[ResultLimitation, ...] = Field(
+        default_factory=tuple, description="能力/数据限制（权威 ResultLimitation，稳定 code）"
+    )
+
+    @computed_field
+    @property
+    def frequency_plan(self) -> BacktestFrequencyPlan:
+        execution = self.config.execution_frequency or self.config.frequency
+
+        def source(frequency: BarFrequency) -> BarSourceMode:
+            return (
+                BarSourceMode.AGGREGATED
+                if frequency in (BarFrequency.H1, BarFrequency.W1)
+                else BarSourceMode.NATIVE
+            )
+
+        return BacktestFrequencyPlan(
+            observation_frequency=self.config.frequency,
+            execution_frequency=execution,
+            observation_source=source(self.config.frequency),
+            execution_source=source(execution),
+        )
+
+    @field_validator("status")
+    @classmethod
+    def _check_completed_only(cls, status: BacktestStatus) -> BacktestStatus:
+        if status is not BacktestStatus.COMPLETED:
+            raise ValueError(
+                f"BacktestResult 只表达 COMPLETED 结果（FAILED 由 BacktestRun.status 表达），"
+                f"实际 {status}"
+            )
+        return status
+
+    @field_validator("limitations", mode="before")
+    @classmethod
+    def _normalize_limitations(cls, value: object) -> object:
+        """权威类型契约：接受 Enum 成员或其稳定字符串 value，统一保存为
+        ResultLimitation 成员；未知 code、重复（成员与字符串等价）拒绝；
+        按 Enum 定义顺序规范化。"""
+        if not isinstance(value, (tuple, list)):
+            return value
+        members: list[ResultLimitation] = []
+        for item in value:
+            if isinstance(item, ResultLimitation):
+                members.append(item)
+            else:
+                try:
+                    members.append(ResultLimitation(item))
+                except ValueError:
+                    raise ValueError(
+                        f"limitations 只允许 ResultLimitation 权威 code，未知：{item!r}"
+                    ) from None
+        if len(set(members)) != len(members):
+            raise ValueError(f"limitations 不允许重复：{tuple(value)}")
+        order = {item: i for i, item in enumerate(ResultLimitation)}
+        return tuple(sorted(members, key=order.__getitem__))
+
+    @model_validator(mode="after")
+    def _check_consistency(self) -> "BacktestResult":
+        points = self.equity_curve.points
+        if not points:
+            empty_fields = (
+                self.started_event_time,
+                self.ended_event_time,
+                self.final_portfolio_snapshot,
+            )
+            if any(field is not None for field in empty_fields):
+                raise ValueError("空 EquityCurve 对应 started/ended/final snapshot 必须均为 None")
+        else:
+            first, last = points[0], points[-1]
+            if self.started_event_time != first.time or self.ended_event_time != last.time:
+                raise ValueError("started/ended_event_time 必须与 EquityCurve 首尾一致")
+            snapshot = self.final_portfolio_snapshot
+            if snapshot is None:
+                raise ValueError("非空 EquityCurve 对应 final_portfolio_snapshot 必须存在")
+            if snapshot.as_of != last.time or snapshot.total_value != last.total_value:
+                raise ValueError(
+                    f"final snapshot（as_of={snapshot.as_of}, "
+                    f"total_value={snapshot.total_value}）必须与最后 EquityPoint"
+                    f"（{last.time}, {last.total_value}）一致"
+                )
+        if self.metrics.fill_count != len(self.fills):
+            raise ValueError(
+                f"metrics.fill_count {self.metrics.fill_count} 必须等于 "
+                f"len(fills) {len(self.fills)}"
+            )
+        ledger_limitations = {
+            ResultLimitation.TRADE_COUNT_UNAVAILABLE,
+            ResultLimitation.WIN_RATE_UNAVAILABLE,
+            ResultLimitation.PRE_TAX_DIVIDEND,
+        }
+        if self.closed_trades and ledger_limitations & set(self.limitations):
+            raise ValueError("已有 ClosedTrade 账本时不得披露旧账本限制")
+        if not self.cash_ledger_entries:
+            missing = ledger_limitations - set(self.limitations)
+            if missing:
+                raise ValueError(
+                    "必需的 CompletedTrade limitation 不得遗漏："
+                    f"{sorted(member.name for member in missing)}"
+                )
+        return self

quant_core/app/backtest/service/backtest_execution_service.py

@@ -0,0 +1,114 @@
+"""唯一历史运行组装：本地与管理入口共享，计算不依赖管理数据库。"""
+
+from decimal import Decimal
+
+from quant_core.app.backtest.backtest_input_schema import BacktestMarketComponents
+from quant_core.app.backtest.backtest_run import BacktestRun
+from quant_core.app.backtest.historical_clock import HistoricalClock
+from quant_core.app.backtest.schema import BacktestConfig, BacktestDataRevision, BacktestResult
+from quant_core.app.factor.interface.public.factor_query import IFactorQuery
+from quant_core.app.factor.schema.factor_contract import FactorIdentity
+from quant_core.app.order_execution.order_execution_dependency import (
+    build_order_api,
+    build_simulated_execution,
+)
+from quant_core.app.portfolio.portfolio_dependency import (
+    build_order_account_listener,
+    build_simulation_account,
+)
+from quant_core.app.strategy.interface.public.strategy import IStrategy
+from quant_core.app.strategy.strategy_dependency import build_strategy_runtime
+from quant_core.app.trading_runtime.runtime_session import RuntimeSession
+from quant_core.app.trading_runtime.strategy_portfolio_adapter import StrategyPortfolioReaderAdapter
+from quant_core.app.trading_runtime.trading_rule_book import EffectiveTradingRuleBook
+
+
+async def execute_backtest(
+    config: BacktestConfig,
+    strategy: IStrategy,
+    components: BacktestMarketComponents,
+    *,
+    slippage_bps: Decimal = Decimal(0),
+    factors: IFactorQuery | None = None,
+    factor_refs: tuple[FactorIdentity, ...] = (),
+    factor_aliases: dict[str, FactorIdentity] | None = None,
+    factor_revision: str | None = None,
+) -> BacktestResult:
+    """消费已准备行情和显式因子查询，返回交易结果，不联网或持久化。"""
+    if slippage_bps < 0 or not slippage_bps.is_finite():
+        raise ValueError("滑点必须为非负有限值")
+    if factor_refs and factors is None:
+        raise ValueError("声明因子依赖时必须提供显式查询")
+    market = components.query
+    listings = {
+        key: (await market.get_instrument(key)).listed_date for key in config.instrument_ids
+    }
+    rules = EffectiveTradingRuleBook(
+        await market.list_trading_rules(
+            list(config.instrument_ids), config.start.date(), config.end.date()
+        )
+    )
+    portfolio = build_simulation_account("backtest-application", config.initial_cash, config.start)
+    execution = build_simulated_execution(
+        slippage_bps, config.execution_policy, build_order_account_listener(portfolio)
+    )
+    order_api = build_order_api(
+        execution, portfolio, rules, config.execution_policy, config.auto_switch_order_value
+    )
+    runtime = build_strategy_runtime(
+        strategy=strategy,
+        market=market,
+        factors=factors,
+        factor_aliases=factor_aliases,
+        identities=factor_refs,
+        dataset_revision=factor_revision,
+        listing_dates={key: value for key, value in listings.items() if value is not None},
+        portfolio=StrategyPortfolioReaderAdapter(portfolio),
+        orders=execution,
+        order_api=order_api,
+        adjustment_type=config.strategy_adjustment_type,
+        frequency=config.frequency,
+    )
+    clock = HistoricalClock()
+    session = RuntimeSession(
+        clock=clock,
+        market_state_resolver=components.market_state_resolver,
+        exchange_state_resolver=components.exchange_state_resolver,
+        order_execution=execution,
+        portfolio=portfolio,
+        strategy_runtime=runtime,
+        order_api=order_api,
+    )
+    run = BacktestRun(
+        config=config,
+        runtime_session=session,
+        order_execution=execution,
+        slice_source=components.slice_source,
+        verification=components.verification,
+        clock=clock,
+        ledger=portfolio,
+        input_revisions=(
+            (
+                BacktestDataRevision(
+                    dataset="market_snapshot",
+                    instrument_id="*",
+                    frequency=config.frequency.value,
+                    revision=components.query.revision,
+                ),
+            )
+            + (
+                (
+                    BacktestDataRevision(
+                        dataset="factor_value",
+                        instrument_id="*",
+                        frequency=factor_refs[0].frequency.value,
+                        revision=factor_revision,
+                    ),
+                )
+                if factor_revision is not None
+                else ()
+            )
+        ),
+        listing_dates={key: value for key, value in listings.items() if value is not None},
+    )
+    return await run.run()