Enhance order target portfolio functionality and add integration tests

- Introduced `last_prices` parameter in `OrderTargetPortfolio` to allow for more accurate order calculations based on recent price data.
- Updated `order_target_portfolio_smart` function to handle both algorithmic orders and price dictionaries, improving flexibility in order submissions.
- Added comprehensive integration tests for `order_target_portfolio_smart`, ensuring correct behavior under various scenarios and validating position adjustments.
- Refactored existing logic to improve clarity and maintainability, including adjustments to safety calculations and error handling for target weights.

Author: Cuizi7

rqalpha/apis/__init__.py

@@ -15,3 +15,6 @@
 from rqalpha.apis.api_abstract import *
 from rqalpha.apis.api_base import *
 from rqalpha.apis.api_rqdatac import *
+
+from rqalpha.mod.rqalpha_mod_sys_accounts.api.api_stock import *
+from rqalpha.mod.rqalpha_mod_sys_accounts.api.api_stock import *

rqalpha/mod/rqalpha_mod_sys_accounts/api/order_target_portfolio.py

@@ -1,17 +1,18 @@
 from typing import Mapping, NamedTuple, cast, Optional, Union
+from collections import defaultdict
 from operator import itemgetter
 
 from pandas import Series, Index, DataFrame
 from numpy import sign, round as np_round, inf
 
 from rqalpha.api import export_as_api
 from rqalpha.apis.api_base import assure_instrument
-from rqalpha.model.order import AlgoOrder, MarketOrder
+from rqalpha.model.order import AlgoOrder, MarketOrder, LimitOrder, OrderStyle
 from rqalpha.model.order import Order
 from rqalpha.environment import Environment
 from rqalpha.const import EXECUTION_PHASE, POSITION_DIRECTION, INSTRUMENT_TYPE, MARKET, DEFAULT_ACCOUNT_TYPE, SIDE, POSITION_EFFECT
 from rqalpha.core.execution_context import ExecutionContext
-from rqalpha.utils.exception import RQApiNotSupportedError
+from rqalpha.utils.exception import RQApiNotSupportedError, RQInvalidArgument
 from rqalpha.utils.functools import lru_cache
 from rqalpha.utils.i18n import gettext as _
 
@@ -34,12 +35,15 @@ def __init__(
         target_weights: Series,
         current_quantities: Series,
         current_closable: Series,
+        last_prices: Series | None,
         env: Environment,
     ):
-        if target_weights[target_weights < 0].any():
-            raise ValueError("target_weights contains negative value: {}".format(target_weights[target_weights < 0]))
-
         index = Index(target_weights.index.union(current_quantities.index).union(current_closable.index))
+        if last_prices is not None:
+            last_prices = last_prices.reindex(index)
+            if last_prices.isna().any():
+                raise RQInvalidArgument(_("prices of {} is not provided").format(last_prices.isna().index[last_prices.isna()]))
+
         self._target_weights = target_weights.reindex(index, fill_value=0)
         self._current_quantities = current_quantities.reindex(index, fill_value=0)
         self._current_closable = current_closable.reindex(index, fill_value=0)
@@ -74,17 +78,22 @@ def __init__(
         self._prices = DataFrame(index=index, columns=["last", "limit_up", "limit_down"], dtype=float)   # type: ignore
         if phase == EXECUTION_PHASE.OPEN_AUCTION:
             # 集合竞价阶段，最近的价格是昨收
-            prev_date = env.data_proxy.get_previous_trading_date(env.trading_dt)
-            for order_book_id in index:
-                bars = env.data_proxy.history_bars(order_book_id, 1, "1d", ["close"], prev_date)
-                self._prices.loc[order_book_id, "last"] = bars["close"][0]
+            if last_prices is not None:
+                self._prices["last"] = last_prices
+            else:
+                prev_date = env.data_proxy.get_previous_trading_date(env.trading_dt)
+                for order_book_id in index:
+                    bars = env.data_proxy.history_bars(order_book_id, 1, "1d", ["close"], prev_date)
+                    self._prices.loc[order_book_id, "last"] = bars["close"][0]
         elif phase == EXECUTION_PHASE.ON_BAR:
             if env.config.base.frequency == "1d":
                 # TODO：根据算法时间选择最近的分钟线作为估值
                 # 当前先选择开盘价
                 for order_book_id in index:
                     bars = env.data_proxy.history_bars(order_book_id, 1, "1d", ["open", "limit_up", "limit_down"], env.trading_dt)
-                    self._prices.loc[order_book_id] = bars[0]
+                    self._prices.loc[order_book_id] = list(bars[0])
+                if last_prices is not None:
+                    self._prices["last"] = last_prices
             elif env.config.base.frequency == "1m":
                 raise NotImplementedError
             else:
@@ -148,8 +157,12 @@ def __call__(
 
         if self._current_quantities.empty and self._target_weights.empty:
             return Series()
-     
-        safety = self.SAFETY
+
+        if self._target_weights.sum() > 0.95:
+            # 如果目标是满仓或者接近满仓，则使用一个较高的 safety 开始下降
+            safety = self.SAFETY
+        else:
+            safety = 1.
         last_proportion_diff = inf
         last_diff = None
         prices = self._prices_settle_ccy
@@ -175,7 +188,7 @@ def __call__(
             proportion_diff = abs(total_proportion - self._target_weights.sum())
             if cash_consumed < cash_available:
                 # TODO: 分别计算 A H 股的可用资金
-                if proportion_diff >= last_proportion_diff and last_diff is not None:
+                if proportion_diff > last_proportion_diff and last_diff is not None:
                     return last_diff
                 last_diff = diff
             last_proportion_diff = proportion_diff
@@ -187,50 +200,67 @@ def __call__(
     EXECUTION_PHASE.OPEN_AUCTION,
     EXECUTION_PHASE.ON_BAR,
 )
-def order_target_portfolio_smart(target_portfolio: Union[Mapping[str, float], Series], algo: Optional[AlgoOrder] = None):
+def order_target_portfolio_smart(
+    target_portfolio: Union[Mapping[str, float], Series], 
+    algo_or_prices: Union[AlgoOrder, dict[str, float], None] = None
+):
     from rqalpha.mod.rqalpha_mod_sys_accounts.api.api_stock import _order_value
 
     env = Environment.get_instance()
-    target_weights = {
+    target_weights = Series({
         assure_instrument(id_or_ins).order_book_id: percent for id_or_ins, percent in target_portfolio.items()
-    }
+    })
     account = env.portfolio.accounts[DEFAULT_ACCOUNT_TYPE.STOCK]
     quantities, closable = {},  {}
     for position in account.get_positions():
         quantities[position.order_book_id] = position.quantity
         closable[position.order_book_id] = position.closable
+    if isinstance(algo_or_prices, dict):
+        style_map: dict[str, OrderStyle] = {
+            order_book_id: LimitOrder(price) for order_book_id, price in algo_or_prices.items()
+        }
+        def _get_style(order_book_id) -> OrderStyle:
+            try:
+                return style_map[order_book_id]
+            except KeyError:
+                raise RQInvalidArgument(_("price of {} is needed, which is not provided in the algo_or_prices").format(order_book_id))
+        prices = Series(algo_or_prices)
+    else:
+        style = algo_or_prices or MarketOrder()
+        _get_style = lambda order_book_id: style
+        prices = None
+
+    if target_weights[target_weights < 0].any():
+        raise ValueError("target_weights contains negative value: {}".format(target_weights[target_weights < 0]))
+    current_quantities = Series(quantities)
+    current_quantities = cast(Series, current_quantities[current_quantities != 0])
+    current_closable = Series(closable).reindex(current_quantities.index, fill_value=0)
+
     adjusting = OrderTargetPortfolio(
         target_weights=Series(target_weights),
-        current_quantities=Series(quantities),
-        current_closable=Series(closable),
+        current_quantities=current_quantities,
+        current_closable=current_closable,
+        last_prices=prices,
         env=env
     )(
         target_value = env.portfolio.total_value,
         cash_available = account.cash,
     )
 
     orders = []
-    style = algo or MarketOrder()
+
     # 先平
     for order_book_id, delta_quantity in cast(Series, (adjusting[adjusting < 0])).items():
         order = env.submit_order(Order.__from_create__(
-            order_book_id,
-            abs(delta_quantity),
-            SIDE.SELL,
-            style,
-            POSITION_EFFECT.CLOSE
+            order_book_id, abs(delta_quantity), SIDE.SELL, _get_style(order_book_id), POSITION_EFFECT.CLOSE
         ))
         if order is not None:
             orders.append(order)
     # 后开
     for order_book_id, delta_quantity in cast(Series, (adjusting[adjusting > 0])).items():
         order_book_id = cast(str, order_book_id)
         order_to_be_submitted = Order.__from_create__(
-            order_book_id,
-            delta_quantity,
-            SIDE.BUY,
-            style,
-            POSITION_EFFECT.OPEN
+            order_book_id, delta_quantity, SIDE.BUY, _get_style(order_book_id), POSITION_EFFECT.OPEN
         )
         order = env.submit_order(order_to_be_submitted)
         if order is None:
@@ -241,7 +271,7 @@ def order_target_portfolio_smart(target_portfolio: Union[Mapping[str, float], Se
                     account.get_position(order_book_id), 
                     env.data_proxy.instrument_not_none(order_book_id), 
                     account.cash, 
-                    style, 
+                    _get_style(order_book_id), 
                     zero_amount_as_exception=False
                 )
         if order is not None:

tests/integration_tests/test_api/test_order_target_portfolio_smart_api.py

@@ -0,0 +1,103 @@
+# -*- coding: utf-8 -*-
+# 版权所有 2019 深圳米筐科技有限公司（下称“米筐科技”）
+#
+# 除非遵守当前许可，否则不得使用本软件。
+#
+#     * 非商业用途（非商业用途指个人出于非商业目的使用本软件，或者高校、研究所等非营利机构出于教育、科研等目的使用本软件）：
+#         遵守 Apache License 2.0（下称“Apache 2.0 许可”），
+#         您可以在以下位置获得 Apache 2.0 许可的副本：http://www.apache.org/licenses/LICENSE-2.0。
+#         除非法律有要求或以书面形式达成协议，否则本软件分发时需保持当前许可“原样”不变，且不得附加任何条件。
+#
+#     * 商业用途（商业用途指个人出于任何商业目的使用本软件，或者法人或其他组织出于任何目的使用本软件）：
+#         未经米筐科技授权，任何个人不得出于任何商业目的使用本软件（包括但不限于向第三方提供、销售、出租、出借、转让本软件、
+#         本软件的衍生产品、引用或借鉴了本软件功能或源代码的产品或服务），任何法人或其他组织不得出于任何目的使用本软件，
+#         否则米筐科技有权追究相应的知识产权侵权责任。
+#         在此前提下，对本软件的使用同样需要遵守 Apache 2.0 许可，Apache 2.0 许可与本许可冲突之处，以本许可为准。
+#         详细的授权流程，请联系 public@ricequant.com 获取。
+
+
+from rqalpha import run_func
+from rqalpha.apis import get_position, is_st_stock, order_target_portfolio_smart
+
+
+def test_order_target_portfolio():
+    config = {
+        "base": {
+            "start_date": "2019-07-30",
+            "end_date": "2019-08-05",
+            "accounts": {
+                "stock": 1000000
+            },
+        },
+        "extra": {
+            "log_level": "error",
+        },
+    }
+
+    def init(context):
+        context.counter = 0
+
+    def handle_bar(context, bar_dict):
+        context.counter += 1
+        if context.counter == 1:
+            order_target_portfolio_smart({
+                "000001.XSHE": 0.1,
+                "000004.XSHE": 0.2,
+            })
+            # 开盘价计算目标仓位
+            assert get_position("000001.XSHE").quantity == 7000   # (1000000 * 0.1) / 14.31 = 6988.12
+            assert get_position("000004.XSHE").quantity == 10800  # (1000000 * 0.2) / 18.5 = 10810.81
+        elif context.counter == 2:
+            order_target_portfolio_smart({
+                "000004.XSHE": 0.1,
+                "000005.XSHE": 0.2,
+                "600519.XSHG": 0.6,
+            }, {
+                "000001.XSHE": 14,
+                "000004.XSHE": 18,
+                "000005.XSHE": 2.92,
+                "600519.XSHG": 970,
+            })
+            assert get_position("000001.XSHE").quantity == 0  # 清仓
+            assert get_position("000004.XSHE").quantity == 5500  # (993695.7496 * 0.1) / 18 = 5520.53
+            assert get_position("000005.XSHE").quantity == 68100  # (993695.7496 * 0.2) / 2.92 = 68061.35
+            assert get_position("600519.XSHG").quantity == 0  # 970 低于 收盘价 无法买进
+
+    return run_func(config=config, init=init, handle_bar=handle_bar)
+
+
+def test_order_target_portfolio_in_signal_mode():
+    config = {
+        "base": {
+            "start_date": "2019-07-30",
+            "end_date": "2019-08-05",
+            "accounts": {
+                "stock": 1000000
+            }
+        },
+        "mod": {
+            "sys_simulation": {
+                "signal": True
+            }
+        }
+    }
+
+    def init(context):
+        context.counter = 0
+
+    def handle_bar(context, handle_bar):
+        context.counter += 1
+        if context.counter == 1:
+            order_target_portfolio_smart({
+                "000001.XSHE": 0.1,
+                "000004.XSHE": 0.2,
+            }, {
+                "000001.XSHE": 14,
+                "000004.XSHE": 10,
+            })
+            assert get_position("000001.XSHE").quantity == 7100   # (1000000 * 0.1) / 14= 7142.86
+            assert get_position("000001.XSHE").avg_price == 14
+            assert get_position("000004.XSHE").quantity == 0  # 价格低过跌停价，被拒单
+
+    return run_func(config=config, init=init, handle_bar=handle_bar)
+

tests/integration_tests/test_backtest_results/test_order_target_portfolio_smart.py

@@ -52,11 +52,6 @@ def open_auction(context, bar_dict):
         },
         "extra": {
             "log_level": "error",
-        },
-        "mod": {
-            "sys_analyser": {
-                "plot": True
-            }
         }
     }