Polish LongBridge hybrid notifications

Author: Pigbibi

application/rebalance_service.py

@@ -19,6 +19,60 @@ def _plan_allocation(plan):
     return dict(plan.get("allocation") or {})
 
 
+def _has_text(value):
+    return bool(str(value or "").strip())
+
+
+def _has_benchmark_context(execution):
+    return any(
+        float(execution.get(key) or 0.0) > 0.0
+        for key in ("benchmark_price", "long_trend_value", "exit_line")
+    )
+
+
+def _build_benchmark_line(execution):
+    if not _has_benchmark_context(execution):
+        return None
+    benchmark_symbol = str(execution.get("benchmark_symbol") or "QQQ")
+    benchmark_price = float(execution.get("benchmark_price") or 0.0)
+    long_trend_value = float(execution.get("long_trend_value") or 0.0)
+    exit_line = float(execution.get("exit_line") or 0.0)
+    return (
+        f"{benchmark_symbol}: {benchmark_price:.2f} | "
+        f"MA200: {long_trend_value:.2f} | Exit: {exit_line:.2f}"
+    )
+
+
+def _append_status_lines(lines, *, execution, translator, signal_key):
+    status_display = str(execution.get("status_display") or "").strip()
+    if status_display:
+        lines.append(translator("market_status", status=status_display))
+
+    deploy_ratio_text = str(execution.get("deploy_ratio_text") or "").strip()
+    if deploy_ratio_text:
+        lines.append(translator("risk_position", ratio=deploy_ratio_text))
+
+    income_ratio_text = str(execution.get("income_ratio_text") or "").strip()
+    if income_ratio_text:
+        lines.append(translator("income_target", ratio=income_ratio_text))
+
+    income_locked_ratio_text = str(execution.get("income_locked_ratio_text") or "").strip()
+    if income_locked_ratio_text:
+        lines.append(translator("income_locked", ratio=income_locked_ratio_text))
+
+    signal_display = str(execution.get("signal_display") or "").strip()
+    if signal_display:
+        lines.append(translator(signal_key, msg=signal_display))
+
+    benchmark_line = _build_benchmark_line(execution)
+    if benchmark_line:
+        lines.append(benchmark_line)
+
+    dashboard_text = str(execution.get("dashboard_text") or "").strip()
+    if dashboard_text:
+        lines.append(dashboard_text)
+
+
 def record_skip_log(skip_logs, *, translator, with_prefix, kind, detail):
     message = translator(kind, detail=detail)
     skip_logs.append(message)
@@ -104,12 +158,6 @@ def run_strategy(
     investable_cash = float(execution["investable_cash"])
     current_min_trade = float(execution["current_min_trade"])
     portfolio_rows = tuple(portfolio["portfolio_rows"])
-    market_status = str(execution["status_display"])
-    signal_message = str(execution["signal_display"])
-    deploy_ratio_text = str(execution["deploy_ratio_text"])
-    income_ratio_text = str(execution["income_ratio_text"])
-    income_locked_ratio_text = str(execution["income_locked_ratio_text"])
-
     def record_dry_run(symbol, side, quantity, price, *, order_type):
         price_text = f"${price:.2f}" if price is not None else "market"
         suffix = " LIMIT" if order_type == "limit" else ""
@@ -216,12 +264,6 @@ def record_dry_run(symbol, side, quantity, price, *, order_type):
         investable_cash = float(execution["investable_cash"])
         current_min_trade = float(execution["current_min_trade"])
         portfolio_rows = tuple(portfolio["portfolio_rows"])
-        market_status = str(execution["status_display"])
-        signal_message = str(execution["signal_display"])
-        deploy_ratio_text = str(execution["deploy_ratio_text"])
-        income_ratio_text = str(execution["income_ratio_text"])
-        income_locked_ratio_text = str(execution["income_locked_ratio_text"])
-
     buy_candidates = [
         symbol
         for symbol in strategy_assets
@@ -339,22 +381,17 @@ def record_dry_run(symbol, side, quantity, price, *, order_type):
         tg_lines = [translator("rebalance_title")]
         if dry_run_only:
             tg_lines.append(translator("dry_run_banner"))
-        tg_lines.extend(
-            [
-                translator("market_status", status=market_status),
-                cash_summary,
-                translator("risk_position", ratio=deploy_ratio_text),
-                translator("income_target", ratio=income_ratio_text),
-                translator("income_locked", ratio=income_locked_ratio_text),
-                translator("signal", msg=signal_message),
-                separator,
-                formatted_logs,
-            ]
+        tg_lines.append(cash_summary)
+        _append_status_lines(
+            tg_lines,
+            execution=execution,
+            translator=translator,
+            signal_key="signal",
         )
+        tg_lines.extend([separator, formatted_logs])
         tg_message = "\n".join(tg_lines)
         send_tg_message(tg_message)
     else:
-        cash_label = translator("cash_label")
         equity_text = f"{total_strategy_equity:,.2f}"
         cash_summary = translator(
             "cash_summary",
@@ -363,33 +400,39 @@ def record_dry_run(symbol, side, quantity, price, *, order_type):
         )
         holdings_lines = []
         for row in portfolio_rows:
-            if len(row) == 1:
-                symbol = row[0]
-                holdings_lines.append(
-                    f"{symbol}: ${market_values[symbol]:,.2f}  {cash_label}: ${available_cash:,.2f}"
-                )
-            else:
-                holdings_lines.append(
-                    "  ".join(
-                        f"{symbol}: ${market_values[symbol]:,.2f}"
-                        for symbol in row
-                    )
+            holdings_lines.append(
+                "  ".join(
+                    f"{symbol}: ${market_values[symbol]:,.2f}"
+                    for symbol in row
                 )
-        no_trade_message = (
-            f"{translator('heartbeat_title')}\n"
-            f"{translator('market_status', status=market_status)}\n"
-            f"{translator('equity', value=equity_text)}\n"
-            f"{cash_summary}\n"
-            f"{separator}\n"
-            + "\n".join(holdings_lines) + "\n"
-            f"{separator}\n"
-            f"{translator('risk_position', ratio=deploy_ratio_text)}\n"
-            f"{translator('income_target', ratio=income_ratio_text)}\n"
-            f"{translator('income_locked', ratio=income_locked_ratio_text)}\n"
-            f"{translator('heartbeat_signal', msg=signal_message)}\n"
-            f"{separator}\n"
-            f"{translator('no_executable_orders') if (skip_logs or note_logs) else translator('no_trades')}"
+            )
+        no_trade_lines = [
+            translator("heartbeat_title"),
+            translator("equity", value=equity_text),
+        ]
+        if dry_run_only:
+            no_trade_lines.append(translator("dry_run_banner"))
+        no_trade_lines.extend(
+            [
+                cash_summary,
+                separator,
+                *holdings_lines,
+                separator,
+            ]
+        )
+        _append_status_lines(
+            no_trade_lines,
+            execution=execution,
+            translator=translator,
+            signal_key="heartbeat_signal",
+        )
+        no_trade_lines.extend(
+            [
+                separator,
+                translator("no_executable_orders") if (skip_logs or note_logs) else translator("no_trades"),
+            ]
         )
+        no_trade_message = "\n".join(no_trade_lines)
         if skip_logs:
             no_trade_message += (
                 f"\n{separator}\n"

decision_mapper.py

@@ -71,6 +71,11 @@ def map_strategy_decision_to_plan(
             "trade_threshold_value",
             "signal_display",
             "status_display",
+            "dashboard_text",
+            "benchmark_symbol",
+            "benchmark_price",
+            "long_trend_value",
+            "exit_line",
             "deploy_ratio_text",
             "income_ratio_text",
             "income_locked_ratio_text",
@@ -81,6 +86,7 @@ def map_strategy_decision_to_plan(
         execution_defaults={
             "signal_display": "",
             "status_display": "",
+            "dashboard_text": "",
             "deploy_ratio_text": "",
             "income_ratio_text": "",
             "income_locked_ratio_text": "",

main.py

@@ -27,6 +27,7 @@
     build_issue_notifier,
     build_prefixer,
     build_sender,
+    build_signal_text,
     build_translator,
 )
 from quant_platform_kit.common.runtime_reports import (
@@ -104,6 +105,9 @@ def get_project_id():
 def t(key, **kwargs):
     return build_translator(NOTIFY_LANG)(key, **kwargs)
 
+
+signal_text = build_signal_text(t)
+
 def with_prefix(message: str) -> str:
     return build_prefixer(ACCOUNT_PREFIX, SERVICE_NAME)(message)
 
@@ -317,7 +321,10 @@ def resolve_rebalance_plan(*, indicators, account_state):
         snapshot = build_portfolio_snapshot_from_account_state(account_state)
         evaluation_inputs["snapshot"] = snapshot
 
-    evaluation = STRATEGY_RUNTIME.evaluate(**evaluation_inputs)
+    evaluation = STRATEGY_RUNTIME.evaluate(
+        signal_text_fn=signal_text,
+        **evaluation_inputs,
+    )
     return map_strategy_decision_to_plan(
         evaluation.decision,
         account_state=account_state if "account_state" in AVAILABLE_INPUTS else None,

notifications/telegram.py

@@ -5,6 +5,15 @@
 import requests
 
 
+SIGNAL_ICONS = {
+    "hold": "💎",
+    "entry": "🚀",
+    "reduce": "⚠️",
+    "exit": "🔴",
+    "idle": "💤",
+}
+
+
 I18N = {
     "zh": {
         "rebalance_title": "🔔 【调仓指令】",
@@ -44,6 +53,11 @@
         "status_expired": "过期",
         "signal_risk_on": "SOXL 站上 {window} 日均线，持有 SOXL，交易层风险仓位 {ratio}",
         "signal_delever": "SOXL 跌破 {window} 日均线，切换至 SOXX，交易层风险仓位 {ratio}",
+        "signal_hold": "趋势持有",
+        "signal_entry": "入场信号",
+        "signal_reduce": "减仓信号",
+        "signal_exit": "离场信号",
+        "signal_idle": "等待信号",
     },
     "en": {
         "rebalance_title": "🔔 【Trade Execution Report】",
@@ -83,6 +97,11 @@
         "status_expired": "Expired",
         "signal_risk_on": "SOXL above {window}d MA, hold SOXL, risk {ratio}",
         "signal_delever": "SOXL below {window}d MA, switch to SOXX, risk {ratio}",
+        "signal_hold": "Trend Hold",
+        "signal_entry": "Entry Signal",
+        "signal_reduce": "Reduce Signal",
+        "signal_exit": "Exit Signal",
+        "signal_idle": "Idle",
     },
 }
 
@@ -96,6 +115,15 @@ def translate(key, **kwargs):
     return translate
 
 
+def build_signal_text(translate_fn):
+    def signal_text(icon_key):
+        emoji = SIGNAL_ICONS.get(icon_key, "❓")
+        name = translate_fn(f"signal_{icon_key}")
+        return f"{emoji} {name}"
+
+    return signal_text
+
+
 def build_prefixer(account_prefix: str, service_name: str):
     def with_prefix(message: str) -> str:
         return f"[{account_prefix}/{service_name}] {message}"

strategy_runtime.py

@@ -43,10 +43,13 @@ def evaluate(
         self,
         *,
         translator: Callable[[str], str],
+        signal_text_fn: Callable[[str], str] | None = None,
         **available_inputs,
     ) -> StrategyEvaluationResult:
         runtime_config = dict(self.runtime_overrides)
         runtime_config.setdefault("translator", translator)
+        if signal_text_fn is not None:
+            runtime_config.setdefault("signal_text_fn", signal_text_fn)
         ctx = build_strategy_context_from_available_inputs(
             entrypoint=self.entrypoint,
             runtime_adapter=self.runtime_adapter,

tests/test_decision_mapper.py

@@ -131,6 +131,10 @@ def test_maps_hybrid_decision_from_snapshot_source(self):
         self.assertEqual(plan["allocation"]["strategy_symbols"], ("TQQQ", "BOXX", "QQQI", "SPYI"))
         self.assertEqual(plan["execution"]["trade_threshold_value"], 250.0)
         self.assertEqual(plan["execution"]["investable_cash"], 5000.0)
+        self.assertEqual(plan["execution"]["benchmark_symbol"], "QQQ")
+        self.assertEqual(plan["execution"]["benchmark_price"], 500.0)
+        self.assertEqual(plan["execution"]["long_trend_value"], 480.0)
+        self.assertEqual(plan["execution"]["exit_line"], 470.0)
         self.assertEqual(plan["portfolio"]["market_values"]["TQQQ"], 5000.0)
 
 

tests/test_rebalance_service.py

@@ -27,6 +27,7 @@
 
 def _build_plan(
     *,
+    strategy_profile="semiconductor_rotation_income",
     strategy_symbols,
     risk_symbols=(),
     income_symbols=(),
@@ -46,9 +47,14 @@ def _build_plan(
     available_cash,
     total_strategy_equity,
     portfolio_rows,
+    dashboard_text="",
+    benchmark_symbol="",
+    benchmark_price=0.0,
+    long_trend_value=0.0,
+    exit_line=0.0,
 ):
     return {
-        "strategy_profile": "semiconductor_rotation_income",
+        "strategy_profile": strategy_profile,
         "allocation": {
             "target_mode": "value",
             "strategy_symbols": tuple(strategy_symbols),
@@ -75,6 +81,11 @@ def _build_plan(
             "income_locked_ratio_text": income_locked_ratio_text,
             "investable_cash": float(investable_cash),
             "current_min_trade": float(current_min_trade),
+            "dashboard_text": dashboard_text,
+            "benchmark_symbol": benchmark_symbol,
+            "benchmark_price": float(benchmark_price),
+            "long_trend_value": float(long_trend_value),
+            "exit_line": float(exit_line),
         },
     }
 
@@ -425,6 +436,49 @@ def test_heartbeat_accepts_normalized_portfolio_and_execution_sections(self):
         self.assertIn("可投资现金", sent_messages[0])
         self.assertIn("SOXX", sent_messages[0])
 
+    def test_hybrid_heartbeat_hides_empty_semiconductor_fields_and_shows_benchmark_line(self):
+        plan = _build_plan(
+            strategy_profile="hybrid_growth_income",
+            strategy_symbols=("TQQQ", "BOXX", "QQQI", "SPYI"),
+            risk_symbols=("TQQQ",),
+            income_symbols=("QQQI", "SPYI"),
+            safe_haven_symbols=("BOXX",),
+            targets={"TQQQ": 0.0, "BOXX": 0.0, "QQQI": 0.0, "SPYI": 0.0},
+            market_values={"TQQQ": 0.0, "BOXX": 0.0, "QQQI": 0.0, "SPYI": 0.0},
+            sellable_quantities={"TQQQ": 0, "BOXX": 0, "QQQI": 0, "SPYI": 0},
+            quantities={"TQQQ": 0, "BOXX": 0, "QQQI": 0, "SPYI": 0},
+            current_min_trade=250.0,
+            trade_threshold_value=250.0,
+            investable_cash=0.0,
+            market_status="",
+            deploy_ratio_text="",
+            income_ratio_text="",
+            income_locked_ratio_text="",
+            signal_message="💤 等待信号",
+            available_cash=0.0,
+            total_strategy_equity=0.0,
+            portfolio_rows=(("TQQQ", "BOXX"), ("QQQI", "SPYI")),
+            benchmark_symbol="QQQ",
+            benchmark_price=588.50,
+            long_trend_value=595.25,
+            exit_line=573.00,
+        )
+
+        sent_messages, _, _ = self._run_strategy(
+            plan,
+            prices={"TQQQ.US": 50.0, "BOXX.US": 100.0, "QQQI.US": 40.0, "SPYI.US": 45.0},
+            dry_run_only=True,
+        )
+
+        self.assertEqual(len(sent_messages), 1)
+        self.assertIn("💓 【心跳检测】", sent_messages[0])
+        self.assertIn("🧪 dry-run 模式", sent_messages[0])
+        self.assertIn("QQQ: 588.50 | MA200: 595.25 | Exit: 573.00", sent_messages[0])
+        self.assertIn("🎯 信号: 💤 等待信号", sent_messages[0])
+        self.assertNotIn("📊 市场状态: ", sent_messages[0])
+        self.assertNotIn("💼 交易层风险仓位: ", sent_messages[0])
+        self.assertNotIn("🏦 收入层锁定占比: ", sent_messages[0])
+
 
 if __name__ == "__main__":
     unittest.main()