修复目标组合风控拒单记录

This commit is contained in:
boris
2026-07-07 09:09:29 +08:00
parent b37ebb81f1
commit 90857fae0a
+171
View File
@@ -2242,6 +2242,23 @@ where
let mut symbols = BTreeSet::new();
symbols.extend(portfolio.positions().keys().cloned());
symbols.extend(target_quantities.keys().cloned());
symbols.extend(
target_weights
.iter()
.filter(|(_, weight)| weight.abs() > f64::EPSILON)
.map(|(symbol, _)| symbol.clone()),
);
self.record_denied_target_portfolio_buys(
date,
portfolio,
data,
target_weights,
&target_quantities,
valuation_prices,
reason,
report,
)?;
for symbol in &symbols {
let current_qty = portfolio
@@ -2340,6 +2357,93 @@ where
Ok(())
}
fn record_denied_target_portfolio_buys(
&self,
date: NaiveDate,
portfolio: &PortfolioState,
data: &DataSet,
target_weights: &BTreeMap<String, f64>,
target_quantities: &BTreeMap<String, u32>,
valuation_prices: Option<&BTreeMap<String, f64>>,
reason: &str,
report: &mut BrokerExecutionReport,
) -> Result<(), BacktestError> {
let equity =
self.rebalance_total_equity_at_with_overrides(date, portfolio, data, valuation_prices)?;
for (symbol, weight) in target_weights {
if weight.abs() <= f64::EPSILON {
continue;
}
let current_qty = portfolio
.position(symbol)
.map(|pos| pos.quantity)
.unwrap_or(0);
let target_qty = target_quantities.get(symbol).copied().unwrap_or(0);
if target_qty > current_qty {
continue;
}
let price = self.rebalance_valuation_price_with_overrides(
date,
symbol,
data,
valuation_prices,
)?;
let minimum_order_quantity = self.minimum_order_quantity(data, symbol);
let order_step_size = self.order_step_size(data, symbol);
let desired_qty = self.round_buy_quantity(
((equity * weight) / price).floor() as u32,
minimum_order_quantity,
order_step_size,
);
if desired_qty <= current_qty {
continue;
}
let Some(rule_reason) = self.buy_target_denial_reason(
date,
portfolio,
data,
symbol,
current_qty,
minimum_order_quantity,
order_step_size,
) else {
continue;
};
let order_id = self.reserve_order_id();
let requested_quantity = desired_qty - current_qty;
let status = zero_fill_status_for_reason(&rule_reason);
report.order_events.push(OrderEvent {
date,
decision_date: None,
order_created_date: None,
execution_date: None,
order_id: Some(order_id),
symbol: symbol.clone(),
side: OrderSide::Buy,
requested_quantity,
filled_quantity: 0,
status,
reason: format!("{reason}: {rule_reason}"),
});
Self::emit_order_process_event(
report,
date,
ProcessEventKind::OrderCreationReject,
order_id,
symbol,
OrderSide::Buy,
format!("status={status:?} reason={rule_reason}"),
);
if report.diagnostics.len() < 32 {
report.diagnostics.push(format!(
"target_portfolio_buy_rejected symbol={} requested={} reason={}",
symbol, requested_quantity, rule_reason
));
}
}
Ok(())
}
fn aiquant_limit_check_price(
&self,
snapshot: &crate::data::DailyMarketSnapshot,
@@ -5993,6 +6097,7 @@ mod tests {
use crate::events::{OrderSide, OrderStatus};
use crate::instrument::Instrument;
use crate::portfolio::PortfolioState;
use crate::risk_control::FidcRiskControlConfig;
use crate::rules::ChinaEquityRuleHooks;
use crate::strategy::{AlgoOrderStyle, OrderIntent, StrategyDecision};
@@ -6939,6 +7044,72 @@ mod tests {
);
}
#[test]
fn target_portfolio_smart_records_buy_rejection_when_target_is_blacklisted() {
let date = chrono::NaiveDate::from_ymd_opt(2025, 1, 2).expect("valid date");
let mut risk_config = FidcRiskControlConfig::default();
risk_config
.static_rules
.blacklisted_symbols
.insert("000001.SZ".to_string());
let broker = BrokerSimulator::new_with_execution_price(
ChinaAShareCostModel::default(),
ChinaEquityRuleHooks,
PriceField::Open,
)
.with_volume_limit(false)
.with_liquidity_limit(false)
.with_risk_config(risk_config);
let data = DataSet::from_components_with_actions_and_quotes(
vec![limit_test_instrument()],
vec![limit_test_snapshot()],
Vec::new(),
vec![limit_test_candidate(true, true)],
vec![limit_test_benchmark()],
Vec::new(),
Vec::new(),
)
.expect("valid dataset");
let mut portfolio = PortfolioState::new(1_000_000.0);
let mut target_weights = BTreeMap::new();
target_weights.insert("000001.SZ".to_string(), 0.50);
let mut report = BrokerExecutionReport::default();
broker
.process_target_portfolio_smart(
date,
&mut portfolio,
&data,
&target_weights,
None,
None,
"target_weights_test",
&mut BTreeMap::new(),
&mut BTreeMap::new(),
&mut None,
&mut BTreeMap::new(),
&mut report,
)
.expect("blacklisted target buy should be rejected, not silently dropped");
assert!(portfolio.position("000001.SZ").is_none());
assert!(report.fill_events.is_empty());
let rejected = report
.order_events
.iter()
.find(|event| event.symbol == "000001.SZ")
.expect("blacklisted target should produce rejected order event");
assert_eq!(rejected.side, OrderSide::Buy);
assert_eq!(rejected.status, OrderStatus::Rejected);
assert_eq!(rejected.filled_quantity, 0);
assert!(rejected.requested_quantity > 0);
assert!(
rejected.reason.contains("blacklisted"),
"{}",
rejected.reason
);
}
#[test]
fn target_portfolio_smart_pre_open_cash_does_not_spend_same_batch_sell_proceeds() {
let date = chrono::NaiveDate::from_ymd_opt(2025, 1, 2).expect("valid date");