Gate LongBridge DCA; keep rotation whole-share (#226)

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: Pigbibi

application/execution_service.py

@@ -261,6 +261,9 @@ class ExecutionCycleResult:
 
 DEFAULT_SAFE_HAVEN_CASH_SUBSTITUTE_THRESHOLD_USD = 1000.0
 SMALL_ACCOUNT_SAFE_HAVEN_CASH_SUBSTITUTE_LIMIT_USD = 2000.0
+MIN_FRACTIONAL_BUY_NOTIONAL_USD = 1.0
+DEFAULT_BUY_QUANTITY_STEP = 1.0
+FRACTIONAL_BUY_QUANTITY_STEP = 0.0001
 SMALL_ACCOUNT_EXISTING_WHOLE_SHARE_RETENTION_SYMBOLS = frozenset({"TQQQ", "SOXL"})
 SMALL_ACCOUNT_EXISTING_WHOLE_SHARE_RETENTION_MIN_TARGET_SHARE_RATIO_BY_SYMBOL = {
     "SOXX": 0.90,
@@ -578,6 +581,13 @@ def _normalize_trade_quantity(quantity):
     return _floor_whole_share_quantity(raw_quantity)
 
 
+def _normalize_buy_quantity(quantity, *, quantity_step: float):
+    raw_quantity = max(0.0, float(quantity or 0.0))
+    if raw_quantity <= 0.0:
+        return 0
+    return normalize_order_quantity(floor_to_quantity_step(raw_quantity, quantity_step))
+
+
 def _market_symbol(symbol, *, symbol_suffix=".US"):
     normalized = str(symbol or "").strip().upper()
     if not normalized:
@@ -773,13 +783,15 @@ def estimate_cash_buy_quantity_safe(
     *,
     estimate_max_purchase_quantity,
     notify_issue,
+    estimate_kwargs=None,
 ):
     try:
         return estimate_max_purchase_quantity(
             trade_context,
             symbol,
             order_kind=order_kind,
             ref_price=ref_price,
+            **dict(estimate_kwargs or {}),
         )
     except Exception:
         notify_issue(
@@ -799,20 +811,24 @@ def _estimate_buy_quantity_candidate(
     estimate_max_purchase_quantity,
     notify_issue,
     dry_run_only=False,
+    quantity_step=DEFAULT_BUY_QUANTITY_STEP,
+    estimate_kwargs=None,
 ):
-    budget_quantity = floor_to_quantity_step(can_buy_value / ref_price, 1.0)
+    budget_quantity = floor_to_quantity_step(can_buy_value / ref_price, quantity_step)
     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,
+        estimate_kwargs=estimate_kwargs,
     )
     if cash_limit_quantity is None:
         return None
-    candidate_quantity = _normalize_trade_quantity(
+    candidate_quantity = _normalize_buy_quantity(
         min(budget_quantity, float(cash_limit_quantity)),
+        quantity_step=quantity_step,
     )
     return candidate_quantity, budget_quantity, float(cash_limit_quantity)
 
@@ -843,6 +859,8 @@ def execute_rebalance_cycle(
     min_order_notional_usd=0.0,
     safe_haven_cash_substitute_threshold_usd=DEFAULT_SAFE_HAVEN_CASH_SUBSTITUTE_THRESHOLD_USD,
     cash_only_execution=True,
+    fractional_buy_execution: bool = False,
+    buy_quantity_step: float = DEFAULT_BUY_QUANTITY_STEP,
 ) -> ExecutionCycleResult:
     logs: list[str] = []
     skip_logs: list[str] = []
@@ -887,16 +905,21 @@ def record_quote_snapshot(snapshot) -> None:
         portfolio=portfolio,
     )
     cash_sweep_symbol = str(portfolio.get("cash_sweep_symbol") or "").strip().upper()
-    plan, allocation = _apply_small_account_whole_share_compatibility(
-        plan=plan,
-        allocation=allocation,
-        strategy_assets=strategy_assets,
-        market_data_port=market_data_port,
-        notify_issue=notify_issue,
-        symbol_suffix=symbol_suffix,
-        limit_buy_premium=limit_buy_premium,
-        limit_buy_premium_by_symbol=limit_buy_premium_by_symbol,
+    estimate_kwargs = {"fractional_shares": True} if fractional_buy_execution else {}
+    effective_buy_quantity_step = (
+        float(buy_quantity_step) if fractional_buy_execution else DEFAULT_BUY_QUANTITY_STEP
     )
+    if not fractional_buy_execution:
+        plan, allocation = _apply_small_account_whole_share_compatibility(
+            plan=plan,
+            allocation=allocation,
+            strategy_assets=strategy_assets,
+            market_data_port=market_data_port,
+            notify_issue=notify_issue,
+            symbol_suffix=symbol_suffix,
+            limit_buy_premium=limit_buy_premium,
+            limit_buy_premium_by_symbol=limit_buy_premium_by_symbol,
+        )
     record_small_account_cash_substitution_notes(
         note_logs,
         allocation=allocation,
@@ -918,7 +941,10 @@ def record_quote_snapshot(snapshot) -> None:
     cash_by_currency = _normalize_cash_by_currency(portfolio.get("cash_by_currency"))
     investable_cash = float(execution["investable_cash"])
     min_order_notional = max(0.0, float(min_order_notional_usd or 0.0))
-    current_min_trade = max(float(execution["current_min_trade"]), min_order_notional)
+    if fractional_buy_execution:
+        current_min_trade = max(float(execution["current_min_trade"]), MIN_FRACTIONAL_BUY_NOTIONAL_USD)
+    else:
+        current_min_trade = max(float(execution["current_min_trade"]), min_order_notional)
     dry_run_sale_proceeds = 0.0
     cash_sweep_sold_this_cycle = False
 
@@ -932,10 +958,17 @@ 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):
+        if fractional_buy_execution and side == "buy":
+            normalized_quantity = _normalize_buy_quantity(
+                quantity,
+                quantity_step=effective_buy_quantity_step,
+            )
+        else:
+            normalized_quantity = _floor_whole_share_quantity(quantity)
         order_intent = OrderIntent(
             symbol=symbol,
             side=side,
-            quantity=_floor_whole_share_quantity(quantity),
+            quantity=normalized_quantity,
             order_type=order_type,
             limit_price=float(submitted_price) if submitted_price is not None else None,
         )
@@ -1240,16 +1273,17 @@ def record_dry_run(symbol, side, quantity, price, *, order_type):
                 allocation,
                 portfolio=portfolio,
             )
-            plan, allocation = _apply_small_account_whole_share_compatibility(
-                plan=plan,
-                allocation=allocation,
-                strategy_assets=tuple(allocation["strategy_symbols"]),
-                market_data_port=market_data_port,
-                notify_issue=notify_issue,
-                symbol_suffix=symbol_suffix,
-                limit_buy_premium=limit_buy_premium,
-                limit_buy_premium_by_symbol=limit_buy_premium_by_symbol,
-            )
+            if not fractional_buy_execution:
+                plan, allocation = _apply_small_account_whole_share_compatibility(
+                    plan=plan,
+                    allocation=allocation,
+                    strategy_assets=tuple(allocation["strategy_symbols"]),
+                    market_data_port=market_data_port,
+                    notify_issue=notify_issue,
+                    symbol_suffix=symbol_suffix,
+                    limit_buy_premium=limit_buy_premium,
+                    limit_buy_premium_by_symbol=limit_buy_premium_by_symbol,
+                )
             record_small_account_cash_substitution_notes(
                 note_logs,
                 allocation=allocation,
@@ -1278,7 +1312,10 @@ def record_dry_run(symbol, side, quantity, price, *, order_type):
             available_cash = float(portfolio["liquid_cash"])
             cash_by_currency = _normalize_cash_by_currency(portfolio.get("cash_by_currency"))
             investable_cash = float(execution["investable_cash"])
-            current_min_trade = max(float(execution["current_min_trade"]), min_order_notional)
+            if fractional_buy_execution:
+                current_min_trade = max(float(execution["current_min_trade"]), MIN_FRACTIONAL_BUY_NOTIONAL_USD)
+            else:
+                current_min_trade = max(float(execution["current_min_trade"]), min_order_notional)
 
     if (
         available_cash <= 0.0
@@ -1313,7 +1350,13 @@ def record_dry_run(symbol, side, quantity, price, *, order_type):
                 notify_issue=notify_issue,
                 quote_recorder=record_quote_snapshot,
             )
-            if price is None or can_buy_value <= price:
+            if price is None:
+                continue
+            if fractional_buy_execution:
+                if can_buy_value >= MIN_FRACTIONAL_BUY_NOTIONAL_USD:
+                    estimated_buy_cost += can_buy_value
+                continue
+            if can_buy_value <= price:
                 continue
             limit_price = _limit_buy_price(
                 symbol, price, limit_buy_premium, limit_buy_premium_by_symbol
@@ -1353,8 +1396,17 @@ def record_dry_run(symbol, side, quantity, price, *, order_type):
         if price is None:
             continue
         can_buy_value = min(diff, investable_cash)
-        if can_buy_value > price:
-            is_limit_order = symbol in limit_order_symbols or symbol == cash_sweep_symbol
+        can_afford_buy = (
+            can_buy_value >= MIN_FRACTIONAL_BUY_NOTIONAL_USD
+            if fractional_buy_execution
+            else can_buy_value > price
+        )
+        if can_afford_buy:
+            is_limit_order = (
+                False
+                if fractional_buy_execution
+                else (symbol in limit_order_symbols or symbol == cash_sweep_symbol)
+            )
             limit_order_kind = "limit" if is_limit_order else "market"
             limit_ref_price = (
                 _limit_buy_price(symbol, price, limit_buy_premium, limit_buy_premium_by_symbol)
@@ -1370,11 +1422,16 @@ def record_dry_run(symbol, side, quantity, price, *, order_type):
                 estimate_max_purchase_quantity=estimate_max_purchase_quantity,
                 notify_issue=notify_issue,
                 dry_run_only=dry_run_only,
+                quantity_step=effective_buy_quantity_step,
+                estimate_kwargs=estimate_kwargs,
             )
             if limit_candidate is None:
                 continue
             limit_candidate_quantity, limit_budget_quantity, limit_cash_limit_quantity = limit_candidate
-            limit_quantity = _normalize_trade_quantity(limit_candidate_quantity)
+            limit_quantity = _normalize_buy_quantity(
+                limit_candidate_quantity,
+                quantity_step=effective_buy_quantity_step,
+            )
             order_kind = limit_order_kind
             ref_price = limit_ref_price
             quantity = limit_quantity

application/longbridge_execution.py

@@ -44,6 +44,8 @@ def submit_order(
     side: str,
     quantity: float,
     submitted_price: float | None = None,
+    allow_fractional_shares: bool = False,
+    quantity_step: float = 1.0,
 ) -> ExecutionReport:
     last_error: Exception | None = None
     for attempt in range(2):
@@ -55,6 +57,8 @@ def submit_order(
                 side=side,
                 quantity=quantity,
                 submitted_price=submitted_price,
+                allow_fractional_shares=allow_fractional_shares,
+                quantity_step=quantity_step,
             )
         except Exception as exc:
             last_error = exc

application/rebalance_service.py

@@ -338,6 +338,8 @@ def fetch_replanned_state():
             min_order_notional_usd=config.min_order_notional_usd,
             safe_haven_cash_substitute_threshold_usd=config.safe_haven_cash_substitute_threshold_usd,
             cash_only_execution=config.cash_only_execution,
+            fractional_buy_execution=config.fractional_buy_execution,
+            buy_quantity_step=config.buy_quantity_step,
         )
         if _should_record_execution_marker(result=execution_result, config=config):
             _record_execution_marker(

application/runtime_composer.py

@@ -19,6 +19,7 @@
 from quant_platform_kit.common.runtime_target import build_runtime_context_fields
 from quant_platform_kit.common.runtime_target import RuntimeTarget
 from notifications.telegram import build_prefixer, build_sender
+from runtime_execution_policy import FRACTIONAL_BUY_QUANTITY_STEP, fractional_buy_execution_enabled
 
 
 @dataclass(frozen=True)
@@ -218,6 +219,7 @@ def build_rebalance_config(
             lambda _error: (),
         )
         plugin_error_lines = tuple(build_plugin_error_lines(strategy_plugin_error))
+        fractional_buy_execution = fractional_buy_execution_enabled(self.strategy_profile)
         return LongBridgeRebalanceConfig(
             limit_sell_discount=self.limit_sell_discount,
             limit_buy_premium=self.limit_buy_premium,
@@ -234,6 +236,8 @@ def build_rebalance_config(
             min_order_notional_usd=self.min_order_notional_usd,
             safe_haven_cash_substitute_threshold_usd=self.safe_haven_cash_substitute_threshold_usd,
             cash_only_execution=bool(cash_only_execution),
+            fractional_buy_execution=fractional_buy_execution,
+            buy_quantity_step=FRACTIONAL_BUY_QUANTITY_STEP if fractional_buy_execution else 1.0,
             sleeper=self.sleeper,
             extra_notification_lines=(market_scope_line, *plugin_lines, *plugin_error_lines),
             notification_title_key=notification_title_key,

application/runtime_dependencies.py

@@ -26,6 +26,8 @@ class LongBridgeRebalanceConfig:
     min_order_notional_usd: float = 100.0
     safe_haven_cash_substitute_threshold_usd: float = 1000.0
     cash_only_execution: bool = True
+    fractional_buy_execution: bool = False
+    buy_quantity_step: float = 1.0
     sleeper: Callable[[float], None] | None = None
     extra_notification_lines: tuple[str, ...] = ()
     notification_title_key: str = ""

main.py

@@ -19,8 +19,10 @@
 from application.rebalance_service import run_strategy as run_rebalance_cycle
 from application.runtime_strategy_adapters import build_runtime_strategy_adapters
 from application.longbridge_execution import submit_order
+from runtime_execution_policy import fractional_buy_execution_enabled, FRACTIONAL_BUY_QUANTITY_STEP
 from application.longbridge_portfolio import fetch_strategy_account_state
 from entrypoints.cloud_run import is_market_open_now
+from runtime_execution_policy import dca_execution_unsupported_reason
 from runtime_config_support import load_platform_runtime_settings
 from notifications.telegram import build_signal_text, build_strategy_display_name, build_translator
 from quant_platform_kit.common.runtime_reports import (
@@ -110,6 +112,27 @@ def get_project_id():
 DEFAULT_SAFE_HAVEN_CASH_SUBSTITUTE_THRESHOLD_USD = 1000.0
 DEFAULT_MIN_ORDER_NOTIONAL_USD = 100.0
 
+_FRACTIONAL_BUY_EXECUTION = fractional_buy_execution_enabled(STRATEGY_PROFILE)
+
+
+def _profile_submit_order(t_ctx, symbol, **kwargs):
+    return submit_order(
+        t_ctx,
+        symbol,
+        allow_fractional_shares=_FRACTIONAL_BUY_EXECUTION,
+        quantity_step=FRACTIONAL_BUY_QUANTITY_STEP if _FRACTIONAL_BUY_EXECUTION else 1.0,
+        **kwargs,
+    )
+
+
+def _profile_estimate_max_purchase_quantity(t_ctx, symbol, **kwargs):
+    return estimate_max_purchase_quantity(
+        t_ctx,
+        symbol,
+        fractional_shares=_FRACTIONAL_BUY_EXECUTION,
+        **kwargs,
+    )
+
 SEPARATOR = "━━━━━━━━━━━━━━━━━━"
 
 
@@ -254,7 +277,7 @@ def log_runtime_warning(message):
         ),
         warning_log_fn=log_runtime_warning,
     ),
-    submit_order_fn=submit_order,
+    submit_order_fn=_profile_submit_order,
     symbol_suffix=SYMBOL_SUFFIX,
     currency=TRADING_CURRENCY,
     cash_only_execution=CASH_ONLY_EXECUTION,
@@ -328,7 +351,7 @@ def build_composer(*, dry_run_only_override: bool | None = None):
         dry_run_only_override=dry_run_only_override,
         broker_adapters=BROKER_ADAPTERS,
         strategy_adapters=STRATEGY_ADAPTERS,
-        estimate_max_purchase_quantity_fn=estimate_max_purchase_quantity,
+        estimate_max_purchase_quantity_fn=_profile_estimate_max_purchase_quantity,
         fetch_order_status_fn=fetch_order_status,
         fetch_token_from_secret_fn=fetch_token_from_secret,
         refresh_token_if_needed_fn=refresh_token_if_needed,
@@ -542,6 +565,30 @@ def run_strategy(*, force_run: bool = False, validation_only: bool = False, vali
                 ),
                 flush=True,
             )
+        unsupported_reason = dca_execution_unsupported_reason(STRATEGY_PROFILE)
+        if unsupported_reason is not None:
+            reporting_adapters.log_event(
+                log_context,
+                "strategy_execution_unsupported",
+                message="Strategy requires fractional-share execution; skip",
+                skip_reason=unsupported_reason,
+                strategy_profile=STRATEGY_PROFILE,
+                market=MARKET,
+                market_calendar=MARKET_CALENDAR,
+                market_timezone=MARKET_TIMEZONE,
+            )
+            finalize_runtime_report(
+                report,
+                status="skipped",
+                diagnostics={"skip_reason": unsupported_reason},
+            )
+            print(
+                composer.with_prefix(
+                    f"Strategy {STRATEGY_PROFILE} requires fractional-share execution; skip."
+                ),
+                flush=True,
+            )
+            return True
         if not validation_only:
             publish_strategy_plugin_alerts(strategy_plugin_signals, report=report)
         notification_delivery_events: list[dict] = []

requirements.txt

@@ -1,7 +1,7 @@
 flask
 gunicorn
-quant-platform-kit @ git+https://github.com/QuantStrategyLab/QuantPlatformKit.git@7b6e3ce33e6563db4794fa7b865db9ec428dc478
-us-equity-strategies @ git+https://github.com/QuantStrategyLab/UsEquityStrategies.git@608f491f4ef083c752ec29ea2669665d5de4a219
+quant-platform-kit @ git+https://github.com/QuantStrategyLab/QuantPlatformKit.git@dfdbef6b58ab46f357d67800510bb9e8c4a01182
+us-equity-strategies @ git+https://github.com/QuantStrategyLab/UsEquityStrategies.git@5537c0ad2ce0d34113381d4af19656b0bcdd82ec
 hk-equity-strategies @ git+https://github.com/QuantStrategyLab/HkEquityStrategies.git@9775fea22a0f397422d27b6a3340934b1ea7f064
 pandas
 requests