Add fractional limit buy fallback

Author: Pigbibi

.github/workflows/sync-cloud-run-env.yml

@@ -37,6 +37,7 @@ jobs:
       NOTIFY_LANG: ${{ vars.NOTIFY_LANG }}
       EXECUTION_REPORT_GCS_URI: ${{ vars.EXECUTION_REPORT_GCS_URI }}
       LONGBRIDGE_DRY_RUN_ONLY: ${{ vars.LONGBRIDGE_DRY_RUN_ONLY }}
+      LONGBRIDGE_FRACTIONAL_LIMIT_BUY_FALLBACK_TO_MARKET: ${{ vars.LONGBRIDGE_FRACTIONAL_LIMIT_BUY_FALLBACK_TO_MARKET }}
       GLOBAL_TELEGRAM_CHAT_ID: ${{ vars.GLOBAL_TELEGRAM_CHAT_ID }}
       TELEGRAM_TOKEN: ${{ secrets.TELEGRAM_TOKEN }}
     steps:
@@ -280,6 +281,11 @@ jobs:
           else
             remove_env_vars+=("LONGBRIDGE_DRY_RUN_ONLY")
           fi
+          if [ -n "${LONGBRIDGE_FRACTIONAL_LIMIT_BUY_FALLBACK_TO_MARKET:-}" ]; then
+            env_pairs+=("LONGBRIDGE_FRACTIONAL_LIMIT_BUY_FALLBACK_TO_MARKET=${LONGBRIDGE_FRACTIONAL_LIMIT_BUY_FALLBACK_TO_MARKET}")
+          else
+            remove_env_vars+=("LONGBRIDGE_FRACTIONAL_LIMIT_BUY_FALLBACK_TO_MARKET")
+          fi
 
           if [ -n "${INCOME_THRESHOLD_USD:-}" ]; then
             env_pairs+=("INCOME_THRESHOLD_USD=${INCOME_THRESHOLD_USD}")
@@ -337,6 +343,7 @@ jobs:
       NOTIFY_LANG: ${{ vars.NOTIFY_LANG }}
       EXECUTION_REPORT_GCS_URI: ${{ vars.EXECUTION_REPORT_GCS_URI }}
       LONGBRIDGE_DRY_RUN_ONLY: ${{ vars.LONGBRIDGE_DRY_RUN_ONLY }}
+      LONGBRIDGE_FRACTIONAL_LIMIT_BUY_FALLBACK_TO_MARKET: ${{ vars.LONGBRIDGE_FRACTIONAL_LIMIT_BUY_FALLBACK_TO_MARKET }}
       GLOBAL_TELEGRAM_CHAT_ID: ${{ vars.GLOBAL_TELEGRAM_CHAT_ID }}
       TELEGRAM_TOKEN: ${{ secrets.TELEGRAM_TOKEN }}
     steps:
@@ -580,6 +587,11 @@ jobs:
           else
             remove_env_vars+=("LONGBRIDGE_DRY_RUN_ONLY")
           fi
+          if [ -n "${LONGBRIDGE_FRACTIONAL_LIMIT_BUY_FALLBACK_TO_MARKET:-}" ]; then
+            env_pairs+=("LONGBRIDGE_FRACTIONAL_LIMIT_BUY_FALLBACK_TO_MARKET=${LONGBRIDGE_FRACTIONAL_LIMIT_BUY_FALLBACK_TO_MARKET}")
+          else
+            remove_env_vars+=("LONGBRIDGE_FRACTIONAL_LIMIT_BUY_FALLBACK_TO_MARKET")
+          fi
 
           if [ -n "${INCOME_THRESHOLD_USD:-}" ]; then
             env_pairs+=("INCOME_THRESHOLD_USD=${INCOME_THRESHOLD_USD}")

README.md

@@ -66,13 +66,14 @@ Telegram notifications include structured execution and heartbeat messages, with
 | `STRATEGY_PROFILE` | Yes | Strategy profile selector. Set explicitly per deployment; enabled values include `global_etf_confidence_vol_gate`, `global_etf_rotation`, `mega_cap_leader_rotation_top50_balanced`, `russell_1000_multi_factor_defensive`, `soxl_soxx_trend_income`, `tech_communication_pullback_enhancement`, and `tqqq_growth_income` |
 | `ACCOUNT_REGION` | No | Account region marker for platform-style deployment (e.g. `HK`, `SG`; defaults to `ACCOUNT_PREFIX` / `DEFAULT`) |
 | `LONGBRIDGE_DRY_RUN_ONLY` | No | Set to `true` to keep the selected deployment in dry-run mode. |
+| `LONGBRIDGE_FRACTIONAL_LIMIT_BUY_FALLBACK_TO_MARKET` | No | Set to `true` to convert fractional `limit buy` orders to `market buy` orders instead of skipping them. |
 | `LONGBRIDGE_DEBUG_POSITION_SNAPSHOT` | No | Set to `true` to log raw LongBridge position quantity and available quantity for troubleshooting. |
 | `INCOME_THRESHOLD_USD` | No | Optional override for the `tqqq_growth_income` income-layer threshold. Leave unset to use the strategy package default. |
 | `QQQI_INCOME_RATIO` | No | Optional override for QQQI's share of the `tqqq_growth_income` income layer, 0–1. |
 | `NOTIFY_LANG` | No | Notification language: `en` (English, default) or `zh` (Chinese) |
 | `GOOGLE_CLOUD_PROJECT` | No | GCP project ID (defaults to ADC project when unset) |
 
-Strategy allocation can still target fractional dollar values and fractional position weights. The LongBridge execution layer submits whole-share orders only because OpenAPI `submit_order` rejects fractional submitted quantities on the tested accounts. When a target value is zero, sell sizing uses the sellable whole-share position quantity instead of re-deriving shares from current price, so liquidation targets do not leave a residual share because of quote drift.
+Strategy allocation can still target fractional dollar values and fractional position weights. The LongBridge execution layer keeps the tested conservative rule: `limit buy` orders stay whole-share only by default, while `market buy` / `market sell` and `limit sell` can preserve fractional quantities when the target quantity is at least 1 share. If you set `LONGBRIDGE_FRACTIONAL_LIMIT_BUY_FALLBACK_TO_MARKET=true`, fractional `limit buy` orders are downgraded to market buys instead of being skipped. When a target value is zero, sell sizing uses the sellable position quantity instead of re-deriving shares from current price, so liquidation targets do not leave a residual share because of quote drift.
 
 Secret Manager must contain the secret named by `LONGPORT_SECRET_NAME` (default: `longport_token_hk`), where the **latest version = active access token**. The app refreshes it when expiry is within 30 days.
 

application/execution_service.py

@@ -76,26 +76,51 @@ def _floor_whole_share_quantity(quantity):
     return normalize_order_quantity(floor_to_quantity_step(quantity, 1.0))
 
 
+def _supports_fractional_quantity(*, order_kind: str, side: str) -> bool:
+    return not (order_kind == "limit" and side == "buy")
+
+
+def _normalize_trade_quantity(quantity, *, allow_fractional: bool):
+    raw_quantity = max(0.0, float(quantity or 0.0))
+    if raw_quantity <= 0.0:
+        return 0
+    if allow_fractional:
+        if raw_quantity < 1.0:
+            return 0
+        return normalize_order_quantity(raw_quantity)
+    return _floor_whole_share_quantity(raw_quantity)
+
+
+def _has_fractional_quantity(quantity) -> bool:
+    value = float(quantity or 0.0)
+    return value > 0.0 and not value.is_integer()
+
+
 def _sell_order_quantity(
     *,
     current_value,
     target_value,
     price,
     sellable_quantity,
+    allow_fractional: bool,
 ):
     sellable = max(0.0, float(sellable_quantity or 0.0))
     if sellable <= 0.0:
         return 0
 
     target = max(0.0, float(target_value or 0.0))
     if target <= 0.0:
-        return _floor_whole_share_quantity(sellable)
+        return _normalize_trade_quantity(
+            sellable,
+            allow_fractional=allow_fractional,
+        )
 
     sell_value = max(0.0, float(current_value or 0.0) - target)
     if sell_value <= 0.0 or float(price or 0.0) <= 0.0:
         return 0
-    return _floor_whole_share_quantity(
+    return _normalize_trade_quantity(
         min(sell_value / float(price), sellable),
+        allow_fractional=allow_fractional,
     )
 
 
@@ -131,6 +156,34 @@ def estimate_cash_buy_quantity_safe(
         return None
 
 
+def _estimate_buy_quantity_candidate(
+    trade_context,
+    symbol,
+    order_kind,
+    ref_price,
+    *,
+    can_buy_value,
+    estimate_max_purchase_quantity,
+    notify_issue,
+):
+    budget_quantity = floor_to_quantity_step(can_buy_value / ref_price, 0.0001)
+    cash_limit_quantity = estimate_cash_buy_quantity_safe(
+        trade_context,
+        symbol,
+        order_kind,
+        ref_price,
+        estimate_max_purchase_quantity=estimate_max_purchase_quantity,
+        notify_issue=notify_issue,
+    )
+    if cash_limit_quantity is None:
+        return None
+    candidate_quantity = _normalize_trade_quantity(
+        min(budget_quantity, float(cash_limit_quantity)),
+        allow_fractional=True,
+    )
+    return candidate_quantity, budget_quantity, float(cash_limit_quantity)
+
+
 def execute_rebalance_cycle(
     *,
     trade_context,
@@ -149,6 +202,7 @@ def execute_rebalance_cycle(
     limit_sell_discount,
     limit_buy_premium,
     dry_run_only=False,
+    fractional_limit_buy_fallback_to_market=False,
     post_sell_refresh_attempts=1,
     post_sell_refresh_interval_sec=0.0,
     sleeper=_noop_sleep,
@@ -183,14 +237,25 @@ def append_order_id_suffix(log_message, order_id):
         return f"{log_message} {suffix}"
 
     def submit_order_via_port(symbol, order_type, side, quantity, log_message, *, submitted_price=None):
+        allow_fractional = _supports_fractional_quantity(order_kind=order_type, side=side)
         order_intent = OrderIntent(
             symbol=symbol,
             side=side,
-            quantity=quantity,
+            quantity=(
+                _normalize_trade_quantity(quantity, allow_fractional=allow_fractional)
+                if allow_fractional
+                else _floor_whole_share_quantity(quantity)
+            ),
             order_type=order_type,
             limit_price=float(submitted_price) if submitted_price is not None else None,
         )
         side_text = "Buy" if side == "buy" else "Sell"
+        if float(order_intent.quantity or 0.0) <= 0.0:
+            notify_issue(
+                "Order submit skipped",
+                f"Symbol: {symbol} Side: {side_text} Qty: {quantity} Type: {order_type} Price: {submitted_price if submitted_price is not None else 'MO'}",
+            )
+            return False
         try:
             report = execution_port.submit_order(order_intent)
         except Exception:
@@ -261,6 +326,10 @@ def record_dry_run(symbol, side, quantity, price, *, order_type):
                 target_value=target_values[symbol],
                 price=price,
                 sellable_quantity=sellable_quantities[symbol],
+                allow_fractional=_supports_fractional_quantity(
+                    order_kind="limit" if symbol in limit_order_symbols else "market",
+                    side="sell",
+                ),
             )
             if quantity > 0:
                 quantity_text = format_quantity(quantity)
@@ -386,28 +455,58 @@ def record_dry_run(symbol, side, quantity, price, *, order_type):
         can_buy_value = min(diff, investable_cash)
         if can_buy_value > price:
             is_limit_order = symbol in limit_order_symbols
-            order_kind = "limit" if is_limit_order else "market"
-            ref_price = round(price * limit_buy_premium, 2) if is_limit_order else round(price, 2)
-            budget_price = ref_price if is_limit_order else price
-            budget_quantity = floor_to_quantity_step(
-                can_buy_value / budget_price,
-                1.0,
-            )
-            cash_limit_quantity = estimate_cash_buy_quantity_safe(
+            limit_order_kind = "limit" if is_limit_order else "market"
+            limit_ref_price = round(price * limit_buy_premium, 2) if is_limit_order else round(price, 2)
+            limit_candidate = _estimate_buy_quantity_candidate(
                 trade_context,
                 f"{symbol}.US",
-                order_kind,
-                ref_price,
+                limit_order_kind,
+                limit_ref_price,
+                can_buy_value=can_buy_value,
                 estimate_max_purchase_quantity=estimate_max_purchase_quantity,
                 notify_issue=notify_issue,
             )
-            if cash_limit_quantity is None:
+            if limit_candidate is None:
                 continue
-            effective_cash_limit_quantity = float(cash_limit_quantity)
-
-            quantity = _floor_whole_share_quantity(
-                min(budget_quantity, effective_cash_limit_quantity),
-            )
+            limit_candidate_quantity, limit_budget_quantity, limit_cash_limit_quantity = limit_candidate
+            if is_limit_order:
+                limit_quantity = _normalize_trade_quantity(
+                    limit_candidate_quantity,
+                    allow_fractional=False,
+                )
+            else:
+                limit_quantity = limit_candidate_quantity
+            order_kind = limit_order_kind
+            ref_price = limit_ref_price
+            quantity = limit_quantity
+            if is_limit_order and fractional_limit_buy_fallback_to_market and _has_fractional_quantity(
+                limit_candidate_quantity
+            ):
+                market_ref_price = round(price, 2)
+                market_candidate = _estimate_buy_quantity_candidate(
+                    trade_context,
+                    f"{symbol}.US",
+                    "market",
+                    market_ref_price,
+                    can_buy_value=can_buy_value,
+                    estimate_max_purchase_quantity=estimate_max_purchase_quantity,
+                    notify_issue=notify_issue,
+                )
+                if market_candidate is not None:
+                    market_quantity, _market_budget_quantity, _market_cash_limit_quantity = market_candidate
+                    if market_quantity >= 1.0:
+                        order_kind = "market"
+                        ref_price = market_ref_price
+                        quantity = market_quantity
+                        fallback_message = translator(
+                            "fractional_limit_buy_fallback_to_market",
+                            symbol=symbol,
+                            qty=format_quantity(quantity),
+                            limit_price=limit_ref_price,
+                            market_price=market_ref_price,
+                        )
+                        note_logs.append(fallback_message)
+                        print(with_prefix(fallback_message), flush=True)
             cost_estimate = 0.0
             if quantity <= 0:
                 record_note_log(
@@ -417,12 +516,12 @@ def record_dry_run(symbol, side, quantity, price, *, order_type):
                     kind="buy_deferred_cash_limit",
                     symbol=f"{symbol}.US",
                     diff=f"{diff:.2f}",
-                    budget_qty=format_quantity(budget_quantity),
+                    budget_qty=format_quantity(limit_budget_quantity),
                 )
                 continue
 
             quantity_text = format_quantity(quantity)
-            if is_limit_order:
+            if order_kind == "limit":
                 if dry_run_only:
                     submitted = record_dry_run(
                         f"{symbol}.US",
@@ -440,7 +539,7 @@ def record_dry_run(symbol, side, quantity, price, *, order_type):
                         translator("limit_buy", symbol=symbol, qty=quantity_text, price=ref_price),
                         submitted_price=ref_price,
                     )
-                cost_estimate = quantity * budget_price
+                cost_estimate = quantity * ref_price
             else:
                 if dry_run_only:
                     submitted = record_dry_run(
@@ -458,7 +557,7 @@ def record_dry_run(symbol, side, quantity, price, *, order_type):
                         quantity,
                         translator("market_buy", symbol=symbol, qty=quantity_text, price=round(price, 2)),
                     )
-                cost_estimate = quantity * budget_price
+                cost_estimate = quantity * price
 
             if submitted:
                 investable_cash = max(0, investable_cash - cost_estimate)

application/rebalance_service.py

@@ -211,6 +211,7 @@ def fetch_replanned_state():
         limit_sell_discount=config.limit_sell_discount,
         limit_buy_premium=config.limit_buy_premium,
         dry_run_only=config.dry_run_only,
+        fractional_limit_buy_fallback_to_market=config.fractional_limit_buy_fallback_to_market,
         post_sell_refresh_attempts=config.post_sell_refresh_attempts,
         post_sell_refresh_interval_sec=config.post_sell_refresh_interval_sec,
         sleeper=config.sleeper or _noop_sleep,

application/runtime_composer.py

@@ -36,6 +36,7 @@ class LongBridgeRuntimeComposer:
     order_poll_interval_sec: int
     order_poll_max_attempts: int
     dry_run_only: bool = False
+    fractional_limit_buy_fallback_to_market: bool = False
     broker_adapters: Any = None
     strategy_adapters: Any = None
     estimate_max_purchase_quantity_fn: Callable[..., float] | None = None
@@ -166,6 +167,7 @@ def build_rebalance_config(self) -> LongBridgeRebalanceConfig:
             with_prefix=self.with_prefix,
             strategy_display_name=self.strategy_display_name_localized,
             dry_run_only=self.dry_run_only,
+            fractional_limit_buy_fallback_to_market=self.fractional_limit_buy_fallback_to_market,
             post_sell_refresh_attempts=self.order_poll_max_attempts,
             post_sell_refresh_interval_sec=self.order_poll_interval_sec,
             sleeper=self.sleeper,
@@ -195,6 +197,7 @@ def build_runtime_composer(
     order_poll_interval_sec: int,
     order_poll_max_attempts: int,
     dry_run_only: bool,
+    fractional_limit_buy_fallback_to_market: bool,
     broker_adapters: Any,
     strategy_adapters: Any,
     estimate_max_purchase_quantity_fn: Callable[..., float],
@@ -234,6 +237,7 @@ def build_runtime_composer(
         order_poll_interval_sec=int(order_poll_interval_sec),
         order_poll_max_attempts=int(order_poll_max_attempts),
         dry_run_only=bool(dry_run_only),
+        fractional_limit_buy_fallback_to_market=bool(fractional_limit_buy_fallback_to_market),
         broker_adapters=broker_adapters,
         strategy_adapters=strategy_adapters,
         estimate_max_purchase_quantity_fn=estimate_max_purchase_quantity_fn,

application/runtime_dependencies.py

@@ -18,6 +18,7 @@ class LongBridgeRebalanceConfig:
     with_prefix: Callable[[str], str]
     strategy_display_name: str = ""
     dry_run_only: bool = False
+    fractional_limit_buy_fallback_to_market: bool = False
     post_sell_refresh_attempts: int = 1
     post_sell_refresh_interval_sec: float = 0.0
     sleeper: Callable[[float], None] | None = None

main.py

@@ -159,6 +159,7 @@ def build_composer():
         order_poll_interval_sec=ORDER_POLL_INTERVAL_SEC,
         order_poll_max_attempts=ORDER_POLL_MAX_ATTEMPTS,
         dry_run_only=RUNTIME_SETTINGS.dry_run_only,
+        fractional_limit_buy_fallback_to_market=RUNTIME_SETTINGS.fractional_limit_buy_fallback_to_market,
         broker_adapters=BROKER_ADAPTERS,
         strategy_adapters=STRATEGY_ADAPTERS,
         estimate_max_purchase_quantity_fn=estimate_max_purchase_quantity,

notifications/telegram.py

@@ -63,6 +63,7 @@
         "buy_deferred_non_usd_cash": "检测到非 USD 现金（{currencies}），但美股策略可用 USD 现金为 ${available}、可投资现金为 ${investable}；请先换汇或入金 USD 后再买入",
         "buy_deferred_small_cash": "{symbol} 目标差额 ${diff}，但可投资现金 ${investable} 不足买入 1 股（价格 ${price}）",
         "buy_deferred_cash_limit": "{symbol} 目标差额 ${diff}，预算可买 {budget_qty} 股，但券商估算可买数量为 0；可能有未完成挂单、结算或购买力占用",
+        "fractional_limit_buy_fallback_to_market": "{symbol} 限价买入碎股不稳定，已改为市价买入 {qty} 股；限价参考价 ${limit_price}，市价参考价 ${market_price}",
         "limit_buy": "📈 [限价买入] {symbol}: {qty}股 @ ${price}",
         "market_buy": "📈 [市价买入] {symbol}: {qty}股 @ ${price}",
         "limit_sell": "📉 [限价卖出] {symbol}: {qty}股 @ ${price}",
@@ -143,6 +144,7 @@
         "buy_deferred_non_usd_cash": "Non-USD cash is present ({currencies}), but this US-equity strategy has USD cash ${available} and investable cash ${investable}; convert or deposit USD before buying",
         "buy_deferred_small_cash": "{symbol} target gap ${diff}, but investable cash ${investable} is not enough for 1 share at ${price}",
         "buy_deferred_cash_limit": "{symbol} target gap ${diff}, budget supports {budget_qty} shares, but broker estimate returned 0; an open order, settlement, or buying-power hold may still be blocking funds",
+        "fractional_limit_buy_fallback_to_market": "{symbol} fractional limit buy is unstable, falling back to market buy for {qty} shares; limit reference ${limit_price}, market reference ${market_price}",
         "limit_buy": "📈 [Limit buy] {symbol}: {qty} shares @ ${price}",
         "market_buy": "📈 [Market buy] {symbol}: {qty} shares @ ${price}",
         "limit_sell": "📉 [Limit sell] {symbol}: {qty} shares @ ${price}",

requirements.txt

@@ -1,7 +1,7 @@
 flask
 gunicorn
-quant-platform-kit @ git+https://github.com/QuantStrategyLab/QuantPlatformKit.git@96f88e30fbb6bc504e8fe79d8248193d887cba28
-us-equity-strategies @ git+https://github.com/QuantStrategyLab/UsEquityStrategies.git@af760b0b5b2fa6ca7817a1acadd10620c02afed8
+./vendor_wheels/quant_platform_kit-0.7.20-py3-none-any.whl
+./vendor_wheels/us_equity_strategies-0.7.35-py3-none-any.whl
 pandas
 requests
 pytz