class PlotStore(object): def __init__(self, env): # type: (Environment) -> None self._env = env self._plots = defaultdict(dict) def add_plot(self, dt, series_name, value): self._plots[series_name][dt] = value def get_plots(self): return self._plots @ExecutionContext.enforce_phase(EXECUTION_PHASE.ON_BAR, EXECUTION_PHASE.ON_TICK, EXECUTION_PHASE.SCHEDULED) @apply_rules( verify_that("series_name", pre_check=True).is_instance_of(str), verify_that("value", pre_check=True).is_number(), ) def plot(self, series_name, value): # type: (str, float) -> None """ 在生成的图标结果中,某一个根线上增加一个点。 :param series_name: 序列名称 :param value: 值 """ self.add_plot(self._env.trading_dt.date(), series_name, value)
def subscribe(id_or_symbols): """ 订阅合约行情。该操作会导致合约池内合约的增加,从而影响handle_bar中处理bar数据的数量。 需要注意,用户在初次编写策略时候需要首先订阅合约行情,否则handle_bar不会被触发。 :param id_or_ins: 标的物 :type id_or_ins: :class:`~Instrument` object | `str` | List[:class:`~Instrument`] | List[`str`] """ current_universe = Environment.get_instance().get_universe() if isinstance(id_or_symbols, six.string_types): order_book_id = instruments(id_or_symbols).order_book_id current_universe.add(order_book_id) elif isinstance(id_or_symbols, Instrument): current_universe.add(id_or_symbols.order_book_id) elif isinstance(id_or_symbols, Iterable): for item in id_or_symbols: current_universe.add(assure_order_book_id(item)) else: raise RQInvalidArgument(_(u"unsupported order_book_id type")) verify_that('id_or_symbols')._are_valid_instruments("subscribe", id_or_symbols) Environment.get_instance().update_universe(current_universe)
class PlotStore(object): def __init__(self, env): # type: (Environment) -> None self._env = env self._plots = defaultdict(dict) def add_plot(self, dt, series_name, value): self._plots[series_name][dt] = value def get_plots(self): return self._plots @ExecutionContext.enforce_phase( EXECUTION_PHASE.ON_BAR, EXECUTION_PHASE.ON_TICK, EXECUTION_PHASE.SCHEDULED ) @apply_rules( verify_that("series_name", pre_check=True).is_instance_of(str), verify_that("value", pre_check=True).is_number(), ) def plot(self, series_name, value): # type: (str, float) -> None """ 在策略运行结束后的收益图中,加入自定义的曲线。 每次调用 plot 函数将会以当前时间为横坐标,value 为纵坐标加入一个点,series_name 相同的点将连成一条曲线。 :param series_name: 曲线名称 :param value: 点的纵坐标值 :example: .. code-block:: python def handle_bar(context, bar_dict): plot("OPEN", bar_dict["000001.XSHE"].open) """ self.add_plot(self._env.trading_dt.date(), series_name, value)
def subscribe(id_or_symbols): # type: (Union[str, Instrument, Iterable[str], Iterable[Instrument]]) -> None """ 订阅合约行情。该操作会导致合约池内合约的增加,从而影响handle_bar中处理bar数据的数量。 需要注意,用户在初次编写策略时候需要首先订阅合约行情,否则handle_bar不会被触发。 :param id_or_symbols: 标的物 """ current_universe = Environment.get_instance().get_universe() if isinstance(id_or_symbols, six.string_types): order_book_id = instruments(id_or_symbols).order_book_id current_universe.add(order_book_id) elif isinstance(id_or_symbols, Instrument): current_universe.add(id_or_symbols.order_book_id) elif isinstance(id_or_symbols, Iterable): for item in id_or_symbols: current_universe.add(assure_order_book_id(item)) else: raise RQInvalidArgument(_(u"unsupported order_book_id type")) verify_that("id_or_symbols")._are_valid_instruments("subscribe", id_or_symbols) Environment.get_instance().update_universe(current_universe)
if order is None: patch_user_exc(KeyError(_(u"Cancel order fail: invalid order id"))) env = Environment.get_instance() if env.can_cancel_order(order): env.broker.cancel_order(order) return order @export_as_api @ExecutionContext.enforce_phase(EXECUTION_PHASE.ON_INIT, EXECUTION_PHASE.BEFORE_TRADING, EXECUTION_PHASE.ON_BAR, EXECUTION_PHASE.ON_TICK, EXECUTION_PHASE.AFTER_TRADING, EXECUTION_PHASE.SCHEDULED) @apply_rules(verify_that('id_or_symbols').are_valid_instruments()) def update_universe(id_or_symbols): """ 该方法用于更新现在关注的证券的集合(e.g.:股票池)。PS:会在下一个bar事件触发时候产生(新的关注的股票池更新)效果。并且update_universe会是覆盖(overwrite)的操作而不是在已有的股票池的基础上进行增量添加。比如已有的股票池为['000001.XSHE', '000024.XSHE']然后调用了update_universe(['000030.XSHE'])之后,股票池就会变成000030.XSHE一个股票了,随后的数据更新也只会跟踪000030.XSHE这一个股票了。 :param id_or_ins: 标的物 :type id_or_ins: :class:`~Instrument` object | `str` | List[:class:`~Instrument`] | List[`str`] """ if isinstance(id_or_symbols, (six.string_types, Instrument)): id_or_symbols = [id_or_symbols] order_book_ids = set( assure_order_book_id(order_book_id) for order_book_id in id_or_symbols) if order_book_ids != Environment.get_instance().get_universe(): Environment.get_instance().update_universe(order_book_ids)
def symbol(order_book_id, split=", "): if isinstance(order_book_id, six.string_types): return "{}[{}]".format(order_book_id, instruments(order_book_id).symbol) else: s = split.join(symbol(item) for item in order_book_id) return s def now_time_str(str_format="%H:%M:%S"): return Environment.get_instance().trading_dt.strftime(str_format) @export_as_api @apply_rules(verify_that('quantity').is_number()) def order(order_book_id, quantity, price=None, style=None): """ 全品种通用智能调仓函数 如果不指定 price, 则相当于下 MarketOrder 如果 order_book_id 是股票,等同于调用 order_shares 如果 order_book_id 是期货,则进行智能下单: * quantity 表示调仓量 * 如果 quantity 为正数,则先平 Sell 方向仓位,再开 Buy 方向仓位 * 如果 quantity 为负数,则先平 Buy 反向仓位,再开 Sell 方向仓位 :param order_book_id: 下单标的物
def export_as_api(func): __all__.append(func.__name__) func = decorate_api_exc(func) return func @export_as_api @ExecutionContext.enforce_phase(EXECUTION_PHASE.ON_BAR, EXECUTION_PHASE.ON_TICK, EXECUTION_PHASE.SCHEDULED, EXECUTION_PHASE.GLOBAL) @apply_rules( verify_that('id_or_ins').is_valid_stock(), verify_that('amount').is_number(), verify_that('style').is_instance_of((MarketOrder, LimitOrder, type(None)))) def order_shares(id_or_ins, amount, price=None, style=None): """ 落指定股数的买/卖单,最常见的落单方式之一。如有需要落单类型当做一个参量传入,如果忽略掉落单类型,那么默认是市价单(market order)。 :param id_or_ins: 下单标的物 :type id_or_ins: :class:`~Instrument` object | `str` :param int amount: 下单量, 正数代表买入,负数代表卖出。将会根据一手xx股来向下调整到一手的倍数,比如中国A股就是调整成100股的倍数。 :param float price: 下单价格,默认为None,表示 :class:`~MarketOrder`, 此参数主要用于简化 `style` 参数。 :param style: 下单类型, 默认是市价单。目前支持的订单类型有 :class:`~LimitOrder` 和 :class:`~MarketOrder` :type style: `OrderStyle` object
from rqalpha.model.instrument import Instrument from rqalpha.model.order import MarketOrder, LimitOrder, OrderStyle, Order from rqalpha.utils.arg_checker import apply_rules, verify_that from rqalpha.utils.functools import instype_singledispatch @export_as_api @ExecutionContext.enforce_phase( EXECUTION_PHASE.OPEN_AUCTION, EXECUTION_PHASE.ON_BAR, EXECUTION_PHASE.ON_TICK, EXECUTION_PHASE.SCHEDULED, EXECUTION_PHASE.GLOBAL ) @apply_rules( verify_that('amount').is_number(), verify_that('style').is_instance_of((MarketOrder, LimitOrder, type(None))) ) @instype_singledispatch def order_shares(id_or_ins, amount, price=None, style=None): # type: (Union[str, Instrument], int, Optional[float], Optional[OrderStyle]) -> Optional[Order] """ 指定股数的买/卖单,最常见的落单方式之一。如有需要落单类型当做一个参量传入,如果忽略掉落单类型,那么默认是市价单(market order)。 :param id_or_ins: 下单标的物 :param amount: 下单量, 正数代表买入,负数代表卖出。将会根据一手xx股来向下调整到一手的倍数,比如中国A股就是调整成100股的倍数。 :param price: 下单价格,默认为None,表示 :class:`~MarketOrder`, 此参数主要用于简化 `style` 参数。 :param style: 下单类型, 默认是市价单。目前支持的订单类型有 :class:`~LimitOrder` 和 :class:`~MarketOrder` :example:
def export_as_api(func): __all__.append(func.__name__) func = decorate_api_exc(func) return func @ExecutionContext.enforce_phase(EXECUTION_PHASE.ON_BAR, EXECUTION_PHASE.ON_TICK, EXECUTION_PHASE.SCHEDULED, EXECUTION_PHASE.GLOBAL) @apply_rules( verify_that('id_or_ins').is_valid_future(), verify_that('amount').is_greater_or_equal_than(0), verify_that('side').is_in([SIDE.BUY, SIDE.SELL]), verify_that('position_effect').is_in( [POSITION_EFFECT.OPEN, POSITION_EFFECT.CLOSE]), verify_that('style').is_instance_of((LimitOrder, MarketOrder, type(None)))) def order(id_or_ins, amount, side, position_effect, style): if not isinstance(style, OrderStyle): raise RuntimeError if amount < 0: raise RuntimeError if amount == 0: user_system_log.warn(_(u"Order Creation Failed: Order amount is 0.")) return None if isinstance(style, LimitOrder) and style.get_limit_price() <= 0: raise RQInvalidArgument(_(u"Limit order price should be positive"))
@export_as_api def symbol(order_book_id, split=", "): if isinstance(order_book_id, six.string_types): return "{}[{}]".format(order_book_id, instruments(order_book_id).symbol) else: s = split.join(symbol(item) for item in order_book_id) return s def now_time_str(str_format="%H:%M:%S"): return Environment.get_instance().trading_dt.strftime(str_format) @export_as_api @apply_rules(verify_that("quantity").is_number()) def order(order_book_id, quantity, price=None, style=None): """ 全品种通用智能调仓函数 如果不指定 price, 则相当于下 MarketOrder 如果 order_book_id 是股票,等同于调用 order_shares 如果 order_book_id 是期货,则进行智能下单: * quantity 表示调仓量 * 如果 quantity 为正数,则先平 Sell 方向仓位,再开 Buy 方向仓位 * 如果 quantity 为负数,则先平 Buy 反向仓位,再开 Sell 方向仓位 :param order_book_id: 下单标的物
def symbol(order_book_id, split=", "): if isinstance(order_book_id, six.string_types): return "{}[{}]".format(order_book_id, instruments(order_book_id).symbol) else: s = split.join(symbol(item) for item in order_book_id) return s def now_time_str(str_format="%H:%M:%S"): return Environment.get_instance().trading_dt.strftime(str_format) @export_as_api @apply_rules(verify_env().portfolio_exists(), verify_that('quantity').is_number()) def order(order_book_id, quantity, price=None, style=None): """ 全品种通用智能调仓函数 如果不指定 price, 则相当于下 MarketOrder 如果 order_book_id 是股票,等同于调用 order_shares 如果 order_book_id 是期货,则进行智能下单: * quantity 表示调仓量 * 如果 quantity 为正数,则先平 Sell 方向仓位,再开 Buy 方向仓位 * 如果 quantity 为负数,则先平 Buy 反向仓位,再开 Sell 方向仓位 :param order_book_id: 下单标的物
from rqalpha import export_as_api from rqalpha.utils.i18n import gettext as _ from . import mod_name @export_as_api def get_positions(booking=None): env = Environment.get_instance() mod = env.mod_dict[mod_name] booking_account = mod.booking_account return booking_account.get_positions(booking) @export_as_api @apply_rules(verify_that('direction').is_in([POSITION_DIRECTION.LONG, POSITION_DIRECTION.SHORT])) def get_position(order_book_id, direction, booking=None): env = Environment.get_instance() mod = env.mod_dict[mod_name] booking_account = mod.booking_account return booking_account.get_position(order_book_id, direction, booking) @export_as_api @apply_rules( verify_that('id_or_ins').is_valid_future(), verify_that('amount').is_number().is_greater_or_equal_than(0), verify_that('side').is_in([SIDE.BUY, SIDE.SELL]), verify_that('position_effect').is_in([POSITION_EFFECT.OPEN, POSITION_EFFECT.CLOSE, POSITION_EFFECT.CLOSE_TODAY]), verify_that('style').is_instance_of((LimitOrder, MarketOrder, type(None)))) def send_order(order_book_id, amount, side, position_effect, style):
EXECUTION_PHASE.ON_TICK, EXECUTION_PHASE.AFTER_TRADING, EXECUTION_PHASE.SCHEDULED, ) def get_open_orders(): """ 获取当日未成交订单数据 :return: List[:class:`~Order` object] """ return Environment.get_instance().broker.get_open_orders() @export_as_api @apply_rules( verify_that("id_or_ins").is_valid_instrument(), verify_that("amount").is_number().is_greater_than(0), verify_that("side").is_in([SIDE.BUY, SIDE.SELL]), ) def submit_order(id_or_ins, amount, side, price=None, position_effect=None): """ 通用下单函数,策略可以通过该函数自由选择参数下单。 :param id_or_ins: 下单标的物 :type id_or_ins: :class:`~Instrument` object | `str` :param float amount: 下单量,需为正数 :param side: 多空方向,多(SIDE.BUY)或空(SIDE.SELL) :type side: :class:`~SIDE` enum
cal_style(price, style)) @sell_close.register(INSTRUMENT_TYPE.FUTURE) def future_sell_close(id_or_ins, amount, price=None, style=None, close_today=False): position_effect = POSITION_EFFECT.CLOSE_TODAY if close_today else POSITION_EFFECT.CLOSE return _submit_order(id_or_ins, amount, SIDE.SELL, position_effect, cal_style(price, style)) @export_as_api @apply_rules(verify_that('underlying_symbol').is_instance_of(str)) def get_future_contracts(underlying_symbol): # type: (str) -> List[str] """ 获取某一期货品种在策略当前日期的可交易合约order_book_id列表。按照到期月份,下标从小到大排列,返回列表中第一个合约对应的就是该品种的近月合约。 :param underlying_symbol: 期货合约品种,例如沪深300股指期货为'IF' :example: 获取某一天的主力合约代码(策略当前日期是20161201): .. code-block:: python [In] logger.info(get_future_contracts('IF'))
@export_as_api def symbol(order_book_id, split=", "): if isinstance(order_book_id, six.string_types): return "{}[{}]".format(order_book_id, instruments(order_book_id).symbol) else: s = split.join(symbol(item) for item in order_book_id) return s def now_time_str(str_format="%H:%M:%S"): return Environment.get_instance().trading_dt.strftime(str_format) @export_as_api @apply_rules(verify_that('quantity').is_number()) def order(order_book_id, quantity, price=None, style=None): """ 全品种通用智能调仓函数 如果不指定 price, 则相当于下 MarketOrder 如果 order_book_id 是股票,等同于调用 order_shares 如果 order_book_id 是期货,则进行智能下单: * quantity 表示调仓量 * 如果 quantity 为正数,则先平 Sell 方向仓位,再开 Buy 方向仓位 * 如果 quantity 为负数,则先平 Buy 反向仓位,再开 Sell 方向仓位 :param order_book_id: 下单标的物
from rqalpha.utils.i18n import gettext as _ from . import mod_name @export_as_api def get_positions(booking=None): env = Environment.get_instance() mod = env.mod_dict[mod_name] booking_account = mod.booking_account return booking_account.get_positions(booking) @export_as_api @apply_rules( verify_that('direction').is_in( [POSITION_DIRECTION.LONG, POSITION_DIRECTION.SHORT])) def get_position(order_book_id, direction, booking=None): env = Environment.get_instance() mod = env.mod_dict[mod_name] booking_account = mod.booking_account return booking_account.get_position(order_book_id, direction, booking) @export_as_api @apply_rules( verify_that('id_or_ins').is_valid_future(), verify_that('amount').is_number().is_greater_or_equal_than(0), verify_that('side').is_in([SIDE.BUY, SIDE.SELL]), verify_that('position_effect').is_in([ POSITION_EFFECT.OPEN, POSITION_EFFECT.CLOSE, POSITION_EFFECT.CLOSE_TODAY
export_as_api(market_close) export_as_api(market_open) export_as_api(industry_code, name='industry_code') export_as_api(sector_code, name='sector_code') @export_as_api @ExecutionContext.enforce_phase( EXECUTION_PHASE.OPEN_AUCTION, EXECUTION_PHASE.ON_BAR, EXECUTION_PHASE.ON_TICK, EXECUTION_PHASE.SCHEDULED, EXECUTION_PHASE.GLOBAL ) @apply_rules(verify_that('id_or_ins').is_valid_stock(), verify_that('amount').is_number(), verify_that('style').is_instance_of((MarketOrder, LimitOrder, type(None)))) def order_shares(id_or_ins, amount, price=None, style=None): # type: (Union[str, Instrument], int, Optional[float], Optional[OrderStyle]) -> Optional[Order] """ 指定股数的买/卖单,最常见的落单方式之一。如有需要落单类型当做一个参量传入,如果忽略掉落单类型,那么默认是市价单(market order)。 :param id_or_ins: 下单标的物 :param amount: 下单量, 正数代表买入,负数代表卖出。将会根据一手xx股来向下调整到一手的倍数,比如中国A股就是调整成100股的倍数。 :param price: 下单价格,默认为None,表示 :class:`~MarketOrder`, 此参数主要用于简化 `style` 参数。 :param style: 下单类型, 默认是市价单。目前支持的订单类型有 :class:`~LimitOrder` 和 :class:`~MarketOrder` :example: .. code-block:: python
def export_as_api(func): __all__.append(func.__name__) func = decorate_api_exc(func) return func @export_as_api @ExecutionContext.enforce_phase(EXECUTION_PHASE.ON_BAR, EXECUTION_PHASE.ON_TICK, EXECUTION_PHASE.SCHEDULED, EXECUTION_PHASE.GLOBAL) @apply_rules(verify_that('id_or_ins').is_valid_stock(), verify_that('amount').is_number(), verify_that('style').is_instance_of((MarketOrder, LimitOrder, type(None)))) def order_shares(id_or_ins, amount, price=None, style=None): """ 落指定股数的买/卖单,最常见的落单方式之一。如有需要落单类型当做一个参量传入,如果忽略掉落单类型,那么默认是市价单(market order)。 :param id_or_ins: 下单标的物 :type id_or_ins: :class:`~Instrument` object | `str` :param int amount: 下单量, 正数代表买入,负数代表卖出。将会根据一手xx股来向下调整到一手的倍数,比如中国A股就是调整成100股的倍数。 :param float price: 下单价格,默认为None,表示 :class:`~MarketOrder`, 此参数主要用于简化 `style` 参数。 :param style: 下单类型, 默认是市价单。目前支持的订单类型有 :class:`~LimitOrder` 和 :class:`~MarketOrder` :type style: `OrderStyle` object
EXECUTION_PHASE.ON_BAR, EXECUTION_PHASE.ON_TICK, EXECUTION_PHASE.AFTER_TRADING, EXECUTION_PHASE.SCHEDULED) def get_open_orders(): """ 获取当日未成交订单数据 :return: List[:class:`~Order` object] """ return Environment.get_instance().broker.get_open_orders() @export_as_api @apply_rules( verify_that("id_or_ins").is_valid_instrument(), verify_that("amount").is_number().is_greater_than(0), verify_that("side").is_in([SIDE.BUY, SIDE.SELL]) ) def submit_order(id_or_ins, amount, side, price=None, position_effect=None): order_book_id = assure_order_book_id(id_or_ins) env = Environment.get_instance() if env.config.base.run_type != RUN_TYPE.BACKTEST: if "88" in order_book_id: raise RQInvalidArgument(_(u"Main Future contracts[88] are not supported in paper trading.")) if "99" in order_book_id: raise RQInvalidArgument(_(u"Index Future contracts[99] are not supported in paper trading.")) style = cal_style(price, None) market_price = env.get_last_price(order_book_id) if not is_valid_price(market_price):
__all__ = [ ] def export_as_api(func): __all__.append(func.__name__) func = decorate_api_exc(func) return func @ExecutionContext.enforce_phase(EXECUTION_PHASE.ON_BAR, EXECUTION_PHASE.ON_TICK, EXECUTION_PHASE.SCHEDULED) @apply_rules(verify_that('id_or_ins').is_valid_future(), verify_that('amount').is_greater_or_equal_than(0), verify_that('side').is_in([SIDE.BUY, SIDE.SELL]), verify_that('position_effect').is_in([POSITION_EFFECT.OPEN, POSITION_EFFECT.CLOSE]), verify_that('style').is_instance_of((LimitOrder, MarketOrder, type(None)))) def order(id_or_ins, amount, side, position_effect, style): if not isinstance(style, OrderStyle): raise RuntimeError if amount < 0: raise RuntimeError if amount == 0: user_system_log.warn(_(u"Order Creation Failed: Order amount is 0.")) return None if isinstance(style, LimitOrder) and style.get_limit_price() <= 0: raise RQInvalidArgument(_(u"Limit order price should be positive"))
EXECUTION_PHASE.ON_TICK, EXECUTION_PHASE.AFTER_TRADING, EXECUTION_PHASE.SCHEDULED, ) def get_open_orders(): # type: () -> List[Order] """ 获取当日未成交订单数据 """ broker = Environment.get_instance().broker return [o for o in broker.get_open_orders() if o.position_effect != POSITION_EFFECT.EXERCISE] @export_as_api @apply_rules( verify_that("id_or_ins").is_valid_instrument(), verify_that("amount").is_number().is_greater_than(0), verify_that("side").is_in([SIDE.BUY, SIDE.SELL]), ) def submit_order(id_or_ins, amount, side, price=None, position_effect=None): # type: (Union[str, Instrument], float, SIDE, Optional[float], Optional[POSITION_EFFECT]) -> Optional[Order] """ 通用下单函数,策略可以通过该函数自由选择参数下单。 :param id_or_ins: 下单标的物 :param amount: 下单量,需为正数 :param side: 多空方向 :param price: 下单价格,默认为None,表示市价单 :param position_effect: 开平方向,交易股票不需要该参数 :example:
@export_as_api def symbol(order_book_id, split=", "): if isinstance(order_book_id, six.string_types): return "{}[{}]".format(order_book_id, instruments(order_book_id).symbol) else: s = split.join(symbol(item) for item in order_book_id) return s def now_time_str(str_format="%H:%M:%S"): return Environment.get_instance().trading_dt.strftime(str_format) @export_as_api @apply_rules(verify_env().portfolio_exists(), verify_that("quantity").is_number()) def order(order_book_id, quantity, price=None, style=None): """ 全品种通用智能调仓函数 如果不指定 price, 则相当于下 MarketOrder 如果 order_book_id 是股票,等同于调用 order_shares 如果 order_book_id 是期货,则进行智能下单: * quantity 表示调仓量 * 如果 quantity 为正数,则先平 Sell 方向仓位,再开 Buy 方向仓位 * 如果 quantity 为负数,则先平 Buy 反向仓位,再开 Sell 方向仓位 :param order_book_id: 下单标的物
from rqalpha.const import POSITION_DIRECTION from rqalpha.environment import Environment __all__ = [] def export_as_api(func): __all__.append(func.__name__) return decorate_api_exc(func) @export_as_api def get_positions(): portfolio = Environment.get_instance().portfolio return reduce(add, (reduce(add, (p.positions for p in itervalues(a.positions)), []) for a in itervalues(portfolio.accounts)), []) @export_as_api @apply_rules( verify_that("direction").is_in( [POSITION_DIRECTION.LONG, POSITION_DIRECTION.SHORT])) def get_position(order_book_id, direction): position_proxy = Environment.get_instance( ).portfolio.positions[order_book_id] if direction == POSITION_DIRECTION.LONG: return position_proxy.long else: return position_proxy.short
EXECUTION_PHASE.ON_BAR, EXECUTION_PHASE.ON_TICK, EXECUTION_PHASE.AFTER_TRADING, EXECUTION_PHASE.SCHEDULED) def get_open_orders(): """ 获取当日未成交订单数据 :return: List[:class:`~Order` object] """ return Environment.get_instance().broker.get_open_orders() @export_as_api @apply_rules( verify_that("id_or_ins").is_valid_instrument(), verify_that("amount").is_number().is_greater_than(0), verify_that("side").is_in([SIDE.BUY, SIDE.SELL]) ) def submit_order(id_or_ins, amount, side, price=None, position_effect=None): """ 通用下单函数,策略可以通过该函数自由选择参数下单。 :param id_or_ins: 下单标的物 :type id_or_ins: :class:`~Instrument` object | `str` :param float amount: 下单量,需为正数 :param side: 多空方向,多(SIDE.BUY)或空(SIDE.SELL) :type side: :class:`~SIDE` enum
def to_date(date): if isinstance(date, datetime.datetime): return date.date() if isinstance(date, datetime.date): return date if isinstance(date, str): return parse(date).date() raise RQInvalidArgument('unknown date value: {}'.format(date)) @export_as_api @apply_rules(verify_that('start_date').is_valid_date()) def get_split(order_book_ids, start_date=None): # type: (Union[str, List[str]], Optional[Union[str, datetime.date]]) -> pd.DataFrame """ 获取某只股票到策略当前日期前一天的拆分情况(包含起止日期)。 :param order_book_ids: 证券代码,证券的独特的标识符,例如:'000001.XSHE' :param start_date: 开始日期,用户必须指定,需要早于策略当前日期 :return: 查询时间段内的某个股票的拆分数据 * ex_dividend_date: 除权除息日,该天股票的价格会因为拆分而进行调整 * book_closure_date: 股权登记日 * split_coefficient_from: 拆分因子(拆分前) * split_coefficient_to: 拆分因子(拆分后)
def symbol(order_book_id, split=", "): if isinstance(order_book_id, six.string_types): return "{}[{}]".format(order_book_id, instruments(order_book_id).symbol) else: s = split.join(symbol(item) for item in order_book_id) return s def now_time_str(str_format="%H:%M:%S"): return Environment.get_instance().trading_dt.strftime(str_format) @export_as_api @apply_rules(verify_env().portfolio_exists(), verify_that("quantity").is_number()) def order(order_book_id, quantity, price=None, style=None): """ 全品种通用智能调仓函数 如果不指定 price, 则相当于下 MarketOrder 如果 order_book_id 是股票,等同于调用 order_shares 如果 order_book_id 是期货,则进行智能下单: * quantity 表示调仓量 * 如果 quantity 为正数,则先平 Sell 方向仓位,再开 Buy 方向仓位 * 如果 quantity 为负数,则先平 Buy 反向仓位,再开 Sell 方向仓位 :param order_book_id: 下单标的物