Read allocation intent in IBKR execution path

Author: Pigbibi

application/execution_service.py

@@ -181,6 +181,27 @@ def _display_text(value: Any, *, fallback: str) -> str:
     return text or fallback
 
 
+def _resolve_weight_allocation(signal_metadata: dict[str, Any] | None) -> dict[str, Any]:
+    metadata = dict(signal_metadata or {})
+    allocation = dict(metadata.get("allocation") or {})
+    if not allocation:
+        raise ValueError("IBKR execution requires signal_metadata.allocation")
+    if allocation.get("target_mode") != "weight":
+        raise ValueError("IBKR execution requires allocation.target_mode=weight")
+    return {
+        "strategy_symbols": tuple(str(symbol).strip().upper() for symbol in allocation.get("strategy_symbols", ())),
+        "risk_symbols": tuple(str(symbol).strip().upper() for symbol in allocation.get("risk_symbols", ())),
+        "income_symbols": tuple(str(symbol).strip().upper() for symbol in allocation.get("income_symbols", ())),
+        "safe_haven_symbols": tuple(
+            str(symbol).strip().upper() for symbol in allocation.get("safe_haven_symbols", ())
+        ),
+        "targets": {
+            str(symbol).strip().upper(): float(weight)
+            for symbol, weight in dict(allocation.get("targets") or {}).items()
+        },
+    }
+
+
 def _apply_snapshot_price_fallbacks(
     prices: dict[str, float],
     symbols,
@@ -358,10 +379,15 @@ def execute_rebalance(
     return_summary=False,
 ):
     """Execute trades to reach target weights."""
+    del target_weights
     signal_metadata = signal_metadata or {}
+    allocation = _resolve_weight_allocation(signal_metadata)
+    target_weights = dict(allocation["targets"])
+    strategy_symbols = tuple(allocation["strategy_symbols"])
     trade_date = str(signal_metadata.get("trade_date") or "").strip() or None
     snapshot_date = _normalize_date_like(signal_metadata.get("snapshot_as_of"))
-    safe_haven_symbol = str(signal_metadata.get("safe_haven_symbol") or "").strip().upper() or None
+    safe_haven_symbols = tuple(allocation["safe_haven_symbols"])
+    safe_haven_symbol = safe_haven_symbols[0] if safe_haven_symbols else None
     equity = account_values.get("equity", 0)
     execution_summary = {
         "mode": "dry_run" if dry_run_only else "paper",

application/rebalance_service.py

@@ -150,6 +150,28 @@ def _build_notification_trade_lines(
     return lines
 
 
+def _resolve_weight_allocation(signal_metadata, *, required: bool) -> dict:
+    metadata = dict(signal_metadata or {})
+    allocation = dict(metadata.get("allocation") or {})
+    if not allocation:
+        if required:
+            raise ValueError("IBKR execution requires signal_metadata.allocation")
+        return {}
+    if allocation.get("target_mode") != "weight":
+        raise ValueError("IBKR execution requires allocation.target_mode=weight")
+    targets = {
+        str(symbol).strip().upper(): float(weight)
+        for symbol, weight in dict(allocation.get("targets") or {}).items()
+    }
+    return {
+        "strategy_symbols": tuple(str(symbol) for symbol in allocation.get("strategy_symbols", ())),
+        "risk_symbols": tuple(str(symbol) for symbol in allocation.get("risk_symbols", ())),
+        "income_symbols": tuple(str(symbol) for symbol in allocation.get("income_symbols", ())),
+        "safe_haven_symbols": tuple(str(symbol) for symbol in allocation.get("safe_haven_symbols", ())),
+        "targets": targets,
+    }
+
+
 def build_dashboard(
     positions,
     account_values,
@@ -173,10 +195,10 @@ def build_dashboard(
         position_lines.append(f"  {symbol}: {qty}股 ${market_value:,.2f}")
     position_text = "\n".join(position_lines) if position_lines else translator("empty_positions")
     signal_metadata = signal_metadata or {}
+    allocation = _resolve_weight_allocation(signal_metadata, required=False)
     target_lines = []
-    if target_weights:
-        for symbol, weight in sorted(target_weights.items(), key=lambda item: (-item[1], item[0])):
-            target_lines.append(f"  {symbol}: {weight:.1%}")
+    for symbol, weight in sorted(allocation.get("targets", {}).items(), key=lambda item: (-item[1], item[0])):
+        target_lines.append(f"  {symbol}: {weight:.1%}")
     target_text = "\n".join(target_lines) if target_lines else translator("empty_target_weights")
     regime = signal_metadata.get("regime")
     breadth_ratio = signal_metadata.get("breadth_ratio")
@@ -239,14 +261,16 @@ def run_strategy_core(
         else:
             target_weights, signal_desc, _is_emergency, status_desc = signal_result
             signal_metadata = {}
+        allocation = _resolve_weight_allocation(signal_metadata, required=target_weights is not None)
+        resolved_target_weights = dict(allocation.get("targets") or {}) if target_weights is not None else None
 
         dashboard = build_dashboard(
             positions,
             account_values,
             signal_desc,
             status_desc,
             strategy_profile=signal_metadata.get("strategy_profile"),
-            target_weights=target_weights,
+            target_weights=resolved_target_weights,
             signal_metadata=signal_metadata,
             translator=translator,
             separator=separator,
@@ -298,10 +322,10 @@ def run_strategy_core(
 
         execution_result = execute_rebalance(
             ib,
-            target_weights,
+            resolved_target_weights,
             positions,
             account_values,
-            strategy_symbols=signal_metadata.get("managed_symbols"),
+            strategy_symbols=allocation.get("strategy_symbols"),
             signal_metadata=signal_metadata,
         )
         if isinstance(execution_result, tuple) and len(execution_result) == 2:
@@ -315,7 +339,7 @@ def run_strategy_core(
             trade_date=signal_metadata.get("trade_date"),
             snapshot_as_of=signal_metadata.get("snapshot_as_of"),
             signal_metadata=signal_metadata,
-            target_weights=target_weights,
+            target_weights=resolved_target_weights,
             execution_summary=execution_summary,
         )
         record_path = write_reconciliation_record(record, output_path=reconciliation_output_path)
@@ -356,7 +380,7 @@ def run_strategy_core(
                 {
                     "result": "OK - executed",
                     "signal_metadata": dict(signal_metadata or {}),
-                    "target_weights": dict(target_weights or {}),
+                    "target_weights": dict(resolved_target_weights or {}),
                     "execution_summary": dict(execution_summary or {}),
                     "reconciliation_record": dict(record),
                     "reconciliation_record_path": str(record_path),

tests/test_execution_service.py

@@ -4,6 +4,36 @@
 from quant_platform_kit.common.models import OrderIntent
 
 
+def _weight_allocation(targets, *, risk_symbols=(), income_symbols=(), safe_haven_symbols=()):
+    ordered_symbols = tuple(targets.keys())
+    return {
+        "target_mode": "weight",
+        "strategy_symbols": ordered_symbols,
+        "risk_symbols": tuple(risk_symbols),
+        "income_symbols": tuple(income_symbols),
+        "safe_haven_symbols": tuple(safe_haven_symbols),
+        "targets": dict(targets),
+    }
+
+
+def _signal_metadata(
+    targets,
+    *,
+    risk_symbols=(),
+    income_symbols=(),
+    safe_haven_symbols=(),
+    **extra,
+):
+    payload = dict(extra)
+    payload["allocation"] = _weight_allocation(
+        targets,
+        risk_symbols=risk_symbols,
+        income_symbols=income_symbols,
+        safe_haven_symbols=safe_haven_symbols,
+    )
+    return payload
+
+
 def translate(key, **kwargs):
     templates = {
         "submitted": "submitted {order_id}",
@@ -66,14 +96,17 @@ def fake_fetch_quote_snapshots(_ib, symbols):
         translator=translate,
         strategy_symbols=["VOO", "BIL"],
         strategy_profile="tech_pullback_cash_buffer",
-        signal_metadata={
-            "regime": "risk_on",
-            "breadth_ratio": 0.6,
-            "target_stock_weight": 0.8,
-            "realized_stock_weight": 0.8,
-            "trade_date": "2026-04-01",
-            "snapshot_as_of": "2026-03-31",
-        },
+        signal_metadata=_signal_metadata(
+            {"VOO": 1.0},
+            risk_symbols=("VOO",),
+            safe_haven_symbols=("BIL",),
+            regime="risk_on",
+            breadth_ratio=0.6,
+            target_stock_weight=0.8,
+            realized_stock_weight=0.8,
+            trade_date="2026-04-01",
+            snapshot_as_of="2026-03-31",
+        ),
         dry_run_only=False,
         cash_reserve_ratio=0.03,
         rebalance_threshold_ratio=0.02,
@@ -113,7 +146,7 @@ def accountValues(self):
         translator=translate,
         strategy_symbols=["VOO"],
         strategy_profile="tech_pullback_cash_buffer",
-        signal_metadata={},
+        signal_metadata=_signal_metadata({"VOO": 1.0}, risk_symbols=("VOO",)),
         dry_run_only=False,
         cash_reserve_ratio=0.03,
         rebalance_threshold_ratio=0.02,
@@ -150,14 +183,17 @@ def fake_fetch_quote_snapshots(_ib, symbols):
         account_group="default",
         service_name="ibkr-paper",
         account_ids=("DU123",),
-        signal_metadata={
-            "regime": "risk_on",
-            "breadth_ratio": 0.6,
-            "target_stock_weight": 0.8,
-            "realized_stock_weight": 0.8,
-            "trade_date": "2026-04-01",
-            "snapshot_as_of": "2026-03-31",
-        },
+        signal_metadata=_signal_metadata(
+            {"VOO": 0.8, "BOXX": 0.2},
+            risk_symbols=("VOO",),
+            safe_haven_symbols=("BOXX",),
+            regime="risk_on",
+            breadth_ratio=0.6,
+            target_stock_weight=0.8,
+            realized_stock_weight=0.8,
+            trade_date="2026-04-01",
+            snapshot_as_of="2026-03-31",
+        ),
         cash_reserve_ratio=0.0,
         rebalance_threshold_ratio=0.02,
         limit_buy_premium=1.005,
@@ -225,7 +261,7 @@ def accountValues(self):
         account_group="default",
         service_name="ibkr-paper",
         account_ids=("DU123",),
-        signal_metadata={"trade_date": "2026-04-01"},
+        signal_metadata=_signal_metadata({"VOO": 1.0}, risk_symbols=("VOO",), trade_date="2026-04-01"),
         dry_run_only=False,
         cash_reserve_ratio=0.0,
         rebalance_threshold_ratio=0.02,
@@ -266,16 +302,19 @@ def fake_fetch_quote_snapshots(_ib, symbols):
         account_group="default",
         service_name="ibkr-paper",
         account_ids=("DU123",),
-        signal_metadata={
-            "regime": "risk_on",
-            "breadth_ratio": 0.6,
-            "target_stock_weight": 0.8,
-            "realized_stock_weight": 0.8,
-            "safe_haven_weight": 0.2,
-            "safe_haven_symbol": "BOXX",
-            "trade_date": "2026-04-01",
-            "snapshot_as_of": "2026-03-31",
-        },
+        signal_metadata=_signal_metadata(
+            {"VOO": 0.8, "BOXX": 0.2},
+            risk_symbols=("VOO",),
+            safe_haven_symbols=("BOXX",),
+            regime="risk_on",
+            breadth_ratio=0.6,
+            target_stock_weight=0.8,
+            realized_stock_weight=0.8,
+            safe_haven_weight=0.2,
+            safe_haven_symbol="BOXX",
+            trade_date="2026-04-01",
+            snapshot_as_of="2026-03-31",
+        ),
         dry_run_only=True,
         cash_reserve_ratio=0.0,
         rebalance_threshold_ratio=0.02,
@@ -315,7 +354,12 @@ def accountValues(self):
         translator=translate,
         strategy_symbols=["VOO"],
         strategy_profile="tech_pullback_cash_buffer",
-        signal_metadata={"trade_date": "2026-04-01", "snapshot_as_of": "2026-03-31"},
+        signal_metadata=_signal_metadata(
+            {"VOO": 1.0},
+            risk_symbols=("VOO",),
+            trade_date="2026-04-01",
+            snapshot_as_of="2026-03-31",
+        ),
         dry_run_only=True,
         cash_reserve_ratio=0.0,
         rebalance_threshold_ratio=0.02,
@@ -352,7 +396,12 @@ def accountValues(self):
         translator=translate,
         strategy_symbols=["VOO"],
         strategy_profile="tech_pullback_cash_buffer",
-        signal_metadata={"trade_date": "2026-04-01", "snapshot_as_of": "2026-03-31"},
+        signal_metadata=_signal_metadata(
+            {"VOO": 1.0},
+            risk_symbols=("VOO",),
+            trade_date="2026-04-01",
+            snapshot_as_of="2026-03-31",
+        ),
         dry_run_only=True,
         cash_reserve_ratio=0.0,
         rebalance_threshold_ratio=0.02,
@@ -389,11 +438,14 @@ def accountValues(self):
         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},
-        },
+        signal_metadata=_signal_metadata(
+            {"VOO": 0.6, "BOXX": 0.4},
+            risk_symbols=("VOO",),
+            safe_haven_symbols=("BOXX",),
+            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,

tests/test_rebalance_service.py

@@ -4,6 +4,17 @@
 from notifications.telegram import build_translator
 
 
+def _weight_allocation(targets, *, risk_symbols=(), income_symbols=(), safe_haven_symbols=()):
+    return {
+        "target_mode": "weight",
+        "strategy_symbols": tuple(targets.keys()),
+        "risk_symbols": tuple(risk_symbols),
+        "income_symbols": tuple(income_symbols),
+        "safe_haven_symbols": tuple(safe_haven_symbols),
+        "targets": dict(targets),
+    }
+
+
 def _build_test_translator():
     templates = {
         "heartbeat_title": "heartbeat",
@@ -64,6 +75,7 @@ def test_build_dashboard_localizes_strategy_details():
             "snapshot_age_days": 8,
             "feature_snapshot_path": "gs://bucket/snapshot.csv",
             "strategy_config_source": "external_config",
+            "allocation": _weight_allocation({}, safe_haven_symbols=("BOXX",)),
         },
         translator=build_translator("zh"),
         separator="---",
@@ -108,7 +120,15 @@ def fake_execute_rebalance(
             "signal",
             False,
             "breadth=60.0%",
-            {"managed_symbols": ("AAA", "BOXX"), "status_icon": "📏"},
+            {
+                "managed_symbols": ("AAA", "BOXX"),
+                "status_icon": "📏",
+                "allocation": _weight_allocation(
+                    {"AAA": 0.9, "BOXX": 0.1},
+                    risk_symbols=("AAA",),
+                    safe_haven_symbols=("BOXX",),
+                ),
+            },
         ),
         execute_rebalance=fake_execute_rebalance,
         send_tg_message=lambda message: observed["messages"].append(message),
@@ -158,6 +178,11 @@ def disconnect(self):
                 "safe_haven_weight": 0.4,
                 "safe_haven_symbol": "BOXX",
                 "dry_run_only": True,
+                "allocation": _weight_allocation(
+                    {"AAA": 0.6, "BOXX": 0.4},
+                    risk_symbols=("AAA",),
+                    safe_haven_symbols=("BOXX",),
+                ),
             },
         ),
         execute_rebalance=lambda *_args, **_kwargs: (