def on_order(self, order: OrderData):
""""""
if order.vt_symbol == self.active_vt_symbol:
if not order.is_active():
self.active_vt_orderid = ""
elif order.vt_symbol == self.passive_vt_symbol:
if not order.is_active():
self.passive_vt_orderid = ""
self.put_variables_event()
def on_query_order(self, data, request):
""""""
for d in data:
local_orderid = self.order_manager.new_local_orderid()
sys_orderid = str(d["id"])
self.order_manager.update_orderid_map(
local_orderid=local_orderid,
sys_orderid=sys_orderid
)
if d["size"] > 0:
direction = Direction.LONG
else:
direction = Direction.SHORT
volume = abs(d["size"])
traded = abs(d["size"] - d["left"])
status = get_order_status(d["status"], volume, traded)
order = OrderData(
orderid=local_orderid,
symbol=d["contract"],
exchange=Exchange.GATEIO,
price=float(d["price"]),
volume=abs(volume),
type=OrderType.LIMIT,
direction=direction,
status=status,
datetime=generate_datetime(d["create_time"]),
gateway_name=self.gateway_name,
)
self.order_manager.on_order(order)
self.gateway.write_log(f"{order.symbol}合约委托信息查询成功")
def on_order(self, l: List, t: int):
""""""
d = l[0]
local_orderid = str(d["text"])[2:]
if d["size"] > 0:
direction = Direction.LONG
else:
direction = Direction.SHORT
volume = abs(d["size"])
traded = abs(d["size"] - d["left"])
status = get_order_status(d["status"], volume, traded)
order = OrderData(
orderid=local_orderid,
symbol=d["contract"],
exchange=Exchange.GATEIO,
price=float(d["price"]),
volume=abs(volume),
type=OrderType.LIMIT,
direction=direction,
status=status,
datetime=generate_datetime(t),
gateway_name=self.gateway_name,
)
self.order_manager.on_order(order)
def send_order(self, strategy: StrategyTemplate, vt_symbol: str,
direction: Direction, offset: Offset, price: float,
volume: float, lock: bool) -> List[str]:
""""""
price = round_to(price, self.priceticks[vt_symbol])
symbol, exchange = extract_vt_symbol(vt_symbol)
self.limit_order_count += 1
order = OrderData(
symbol=symbol,
exchange=exchange,
orderid=str(self.limit_order_count),
direction=direction,
offset=offset,
price=price,
volume=volume,
status=Status.SUBMITTING,
datetime=self.datetime,
gateway_name=self.gateway_name,
)
self.active_limit_orders[order.vt_orderid] = order
self.limit_orders[order.vt_orderid] = order
return [order.vt_orderid]
def on_order(self, d):
""""""
order = OrderData(
symbol=d["instrument_id"],
exchange=Exchange.OKEX,
type=ORDERTYPE_OKEX2VT[d["type"]],
orderid=d["client_oid"],
direction=DIRECTION_OKEX2VT[d["side"]],
price=float(d["price"]),
volume=float(d["size"]),
traded=float(d["filled_size"]),
datetime=generate_datetime(d["timestamp"]),
status=STATUS_OKEX2VT[d["status"]],
gateway_name=self.gateway_name,
)
self.gateway.on_order(copy(order))
trade_volume = d.get("last_fill_qty", 0)
if not trade_volume or float(trade_volume) == 0:
return
self.trade_count += 1
tradeid = f"{self.connect_time}{self.trade_count}"
trade = TradeData(symbol=order.symbol,
exchange=order.exchange,
orderid=order.orderid,
tradeid=tradeid,
direction=order.direction,
price=float(d["last_fill_px"]),
volume=float(trade_volume),
datetime=generate_datetime(d["last_fill_time"]),
gateway_name=self.gateway_name)
self.gateway.on_trade(trade)
def send_limit_order(
self,
direction: Direction,
offset: Offset,
price: float,
volume: float
):
""""""
self.limit_order_count += 1
order = OrderData(
symbol=self.symbol,
exchange=self.exchange,
orderid=str(self.limit_order_count),
direction=direction,
offset=offset,
price=price,
volume=volume,
status=Status.SUBMITTING,
gateway_name=self.gateway_name,
datetime=self.datetime
)
self.active_limit_orders[order.vt_orderid] = order
self.limit_orders[order.vt_orderid] = order
return order.vt_orderid
def on_query_order(self, data: dict, request: Request) -> None:
""""""
if self.check_error(data, "查询活动委托"):
return
for d in data["data"]["orders"]:
timestamp = d["created_at"]
dt = generate_datetime(timestamp / 1000)
if d["client_order_id"]:
orderid = d["client_order_id"]
else:
orderid = d["order_id"]
order = OrderData(
orderid=orderid,
symbol=d["contract_code"],
exchange=Exchange.HUOBI,
price=d["price"],
volume=d["volume"],
type=ORDERTYPE_HUOBIS2VT[d["order_price_type"]],
direction=DIRECTION_HUOBIS2VT[d["direction"]],
offset=OFFSET_HUOBIS2VT[d["offset"]],
traded=d["trade_volume"],
status=STATUS_HUOBIS2VT[d["status"]],
datetime=dt,
gateway_name=self.gateway_name,
)
self.gateway.on_order(order)
self.gateway.write_log(f"{request.extra}活动委托信息查询成功")
def on_query_order(self, data: dict, request: Request) -> None:
""""""
if self.check_error(data, "查询委托"):
return
for d in data["data"]:
direction, order_type = ORDERTYPE_HUOBI2VT[d["type"]]
dt = generate_datetime(d["created-at"] / 1000)
order = OrderData(
orderid=d["client-order-id"],
symbol=d["symbol"],
exchange=Exchange.HUOBI,
price=float(d["price"]),
volume=float(d["amount"]),
type=order_type,
direction=direction,
traded=float(d["filled-amount"]),
status=STATUS_HUOBI2VT.get(d["state"], None),
datetime=dt,
gateway_name=self.gateway_name,
)
self.gateway.on_order(order)
self.gateway.write_log("委托信息查询成功")
def cross_order(self, order: OrderData, tick: TickData):
""""""
contract = self.main_engine.get_contract(order.vt_symbol)
trade_price = 0
# Cross market order immediately after received
if order.type == OrderType.MARKET:
if order.direction == Direction.LONG:
trade_price = tick.ask_price_1 + self.trade_slippage * contract.pricetick
else:
trade_price = tick.bid_price_1 - self.trade_slippage * contract.pricetick
# Cross limit order only if price touched
elif order.type == OrderType.LIMIT:
if order.direction == Direction.LONG:
if order.price >= tick.ask_price_1:
trade_price = tick.ask_price_1
else:
if order.price <= tick.bid_price_1:
trade_price = tick.bid_price_1
# Cross limit order only if price broken
elif order.type == OrderType.STOP:
if order.direction == Direction.LONG:
if tick.ask_price_1 >= order.price:
trade_price = tick.ask_price_1 + self.trade_slippage * contract.pricetick
else:
if tick.bid_price_1 <= order.price:
trade_price = tick.bid_price_1 - self.trade_slippage * contract.pricetick
if trade_price:
order.status = Status.ALLTRADED
order.traded = order.volume
self.put_event(EVENT_ORDER, order)
trade = TradeData(symbol=order.symbol,
exchange=order.exchange,
orderid=order.orderid,
tradeid=order.orderid,
direction=order.direction,
offset=order.offset,
price=trade_price,
volume=order.volume,
datetime=datetime.now(LOCAL_TZ),
gateway_name=order.gateway_name)
self.put_event(EVENT_TRADE, trade)
self.update_position(trade, contract)
def update_order(self, order: OrderData) -> None:
"""
Callback of new order data update.
"""
self.orders[order.vt_orderid] = order
if not order.is_active() and order.vt_orderid in self.active_orderids:
self.active_orderids.remove(order.vt_orderid)
def on_order(self, order: OrderData):
""""""
self.traded = order.traded
self.order_status = order.status
if not order.is_active():
self.stop()
self.put_variables_event()
def on_order(self, order: OrderData):
""""""
msg = f"委托号：{order.vt_orderid}，委托状态：{order.status.value}"
self.write_log(msg)
if not order.is_active():
self.vt_orderid = ""
self.put_variables_event()
def update_order(self, order: OrderData):
""""""
if self.active:
if order.is_active():
self.active_orders[order.vt_orderid] = order
elif order.vt_orderid in self.active_orders:
self.active_orders.pop(order.vt_orderid)
self.on_order(order)
def on_order(self, packet: dict) -> None:
""""""
ord_data = packet["o"]
key = (ord_data["o"], ord_data["f"])
order_type = ORDERTYPE_BINANCES2VT.get(key, None)
if not order_type:
return
order = OrderData(
symbol=ord_data["s"],
exchange=Exchange.BINANCE,
orderid=str(ord_data["c"]),
type=order_type,
direction=DIRECTION_BINANCES2VT[ord_data["S"]],
price=float(ord_data["p"]),
volume=float(ord_data["q"]),
traded=float(ord_data["z"]),
last_traded_volume=float(ord_data["l"]),
status=STATUS_BINANCES2VT[ord_data["X"]],
datetime=generate_datetime(packet["E"]),
gateway_name=self.gateway_name
)
# Push trade event
trade_volume = float(ord_data["l"])
if trade_volume:
trade_data = TradeData(
symbol=order.symbol,
exchange=order.exchange,
orderid=order.orderid,
tradeid=ord_data["t"],
direction=order.direction,
price=float(ord_data["L"]),
volume=trade_volume,
datetime=generate_datetime(ord_data["T"]),
gateway_name=self.gateway_name,
)
order.trade_data = trade_data
else:
order.trade_data = None
self.gateway.on_order(order)
def on_order(self, packet: dict):
""""""
if packet["C"] == "":
orderid = packet["c"]
else:
orderid = packet["C"]
order = OrderData(
symbol=packet["s"].lower(),
exchange=Exchange.BINANCE,
orderid=orderid,
type=ORDERTYPE_BINANCE2VT[packet["o"]],
direction=DIRECTION_BINANCE2VT[packet["S"]],
price=float(packet["p"]),
volume=float(packet["q"]),
traded=float(packet["z"]),
status=STATUS_BINANCE2VT[packet["X"]],
datetime=generate_datetime(packet["O"]),
gateway_name=self.gateway_name
)
# Push trade event
trade_volume = float(packet["l"])
if trade_volume:
trade_data = TradeData(
symbol=order.symbol,
exchange=order.exchange,
orderid=order.orderid,
tradeid=packet["t"],
direction=order.direction,
price=float(packet["L"]),
volume=trade_volume,
datetime=generate_datetime(packet["T"]),
gateway_name=self.gateway_name,
)
order.trade_data = trade_data
else:
order.trade_data = None
self.gateway.on_order(order)
def on_order(self, order: OrderData):
"""
Callback of new order data update.
"""
vt_orderid = order.vt_orderid
if not order.is_active():
if vt_orderid in self.active_orderids:
self.active_orderids.remove(vt_orderid)
if vt_orderid in self.cancel_orderids:
self.cancel_orderids.remove(vt_orderid)
def check_order_valid(self, order: OrderData,
contract: ContractData) -> Optional[PositionData]:
""""""
# Reject unsupported order type
if order.type in {OrderType.FAK, OrderType.FOK, OrderType.RFQ}:
order.status = Status.REJECTED
elif order.type == OrderType.STOP and not contract.stop_supported:
order.status = Status.REJECTED
if order.status == Status.REJECTED:
self.write_log(f"委托被拒单，不支持的委托类型{order.type.value}")
# Reject close order if no more available position
if contract.net_position or order.offset == Offset.OPEN:
return
if order.direction == Direction.LONG:
short_position = self.get_position(order.vt_symbol,
Direction.SHORT)
available = short_position.volume - short_position.frozen
if order.volume > available:
order.status = Status.REJECTED
else:
short_position.frozen += order.volume
return short_position
else:
long_position = self.get_position(order.vt_symbol, Direction.LONG)
available = long_position.volume - long_position.frozen
if order.volume > available:
order.status = Status.REJECTED
else:
long_position.frozen += order.volume
return long_position
if order.status == Status.REJECTED:
self.write_log(f"委托被拒单，可平仓位不足")
def on_query_order(self, data, request):
""""""
order = OrderData(
orderid=data["clientOrderId"],
symbol=data["symbol"].lower(),
exchange=Exchange.BINANCE,
price=float(data["price"]),
volume=float(data["origQty"]),
type=ORDERTYPE_BINANCE2VT[data["type"]],
direction=DIRECTION_BINANCE2VT[data["side"]],
traded=float(data["executedQty"]),
status=STATUS_BINANCE2VT.get(data["status"], None),
datetime=generate_datetime(data["time"]),
gateway_name=self.gateway_name,
)
self.gateway.on_order(order)
self.gateway.write_log("委托订单查询成功")
def on_query_order(self, data: dict, request: Request) -> None:
""""""
for order_data in data["order_info"]:
direction = SIDE_OKEXO2VT[order_data["side"]]
order = OrderData(
symbol=order_data["instrument_id"],
exchange=Exchange.OKEX,
type=ORDERTYPE_OKEXO2VT[order_data["order_type"]],
orderid=order_data["client_oid"],
direction=direction,
traded=int(order_data["filled_qty"]),
price=float(order_data["price"]),
volume=float(order_data["size"]),
datetime=generate_datetime(order_data["timestamp"]),
status=STATE_OKEXO2VT[order_data["state"]],
gateway_name=self.gateway_name,
)
self.gateway.on_order(order)
def on_order(self, data: dict) -> None:
""""""
dt = generate_datetime(data["created_at"] / 1000)
if data["client_order_id"]:
orderid = data["client_order_id"]
else:
orderid = data["order_id"]
order = OrderData(symbol=data["contract_code"],
exchange=Exchange.HUOBI,
orderid=orderid,
type=ORDERTYPE_HUOBIS2VT[data["order_price_type"]],
direction=DIRECTION_HUOBIS2VT[data["direction"]],
offset=OFFSET_HUOBIS2VT[data["offset"]],
price=data["price"],
volume=data["volume"],
traded=data["trade_volume"],
status=STATUS_HUOBIS2VT[data["status"]],
datetime=dt,
gateway_name=self.gateway_name)
self.gateway.on_order(order)
# Push trade event
trades = data["trade"]
if not trades:
return
for d in trades:
dt = generate_datetime(d["created_at"] / 1000)
trade = TradeData(
symbol=order.symbol,
exchange=Exchange.HUOBI,
orderid=order.orderid,
tradeid=str(d["id"]),
direction=order.direction,
offset=order.offset,
price=d["trade_price"],
volume=d["trade_volume"],
datetime=dt,
gateway_name=self.gateway_name,
)
self.gateway.on_trade(trade)
def on_query_order(self, data, request):
""""""
for order_data in data:
order = OrderData(
symbol=order_data["instrument_id"],
exchange=Exchange.OKEX,
type=ORDERTYPE_OKEX2VT[order_data["type"]],
orderid=order_data["client_oid"],
direction=DIRECTION_OKEX2VT[order_data["side"]],
price=float(order_data["price"]),
volume=float(order_data["size"]),
traded=float(order_data["filled_size"]),
datetime=generate_datetime["timestamp"],
status=STATUS_OKEX2VT[order_data["status"]],
gateway_name=self.gateway_name,
)
self.gateway.on_order(order)
self.gateway.write_log("委托信息查询成功")
def on_query_order(self, data, request):
""""""
for order_data in data["order_info"]:
offset, direction = TYPE_OKEXF2VT[order_data["type"]]
order = OrderData(
symbol=order_data["instrument_id"],
exchange=Exchange.OKEX,
type=ORDERTYPE_OKEXF2VT[order_data["order_type"]],
orderid=order_data["client_oid"],
direction=direction,
offset=offset,
traded=int(order_data["filled_qty"]),
price=float(order_data["price"]),
volume=float(order_data["size"]),
datetime=utc_to_local(order_data["timestamp"]),
status=STATUS_OKEXF2VT[order_data["status"]],
gateway_name=self.gateway_name,
)
self.gateway.on_order(order)
def _parse_order_info(order_info, gateway_name: str):
offset, direction = TYPE_OKEXS2VT[order_info["type"]]
order_id = order_info["client_oid"]
if not order_id:
order_id = order_info["order_id"]
order = OrderData(
symbol=order_info["instrument_id"],
exchange=Exchange.OKEX,
type=ORDERTYPE_OKEXS2VT[order_info["order_type"]],
orderid=order_id,
direction=direction,
offset=offset,
traded=int(order_info["filled_qty"]),
price=float(order_info["price"]),
volume=float(order_info["size"]),
datetime=_parse_timestamp(order_info["timestamp"]),
status=STATUS_OKEXS2VT[order_info["status"]],
gateway_name=gateway_name,
)
return order
def on_order(self, data: dict) -> None:
""""""
direction = SIDE_OKEXO2VT[data["side"]]
order = OrderData(
symbol=data["instrument_id"],
exchange=Exchange.OKEX,
type=ORDERTYPE_OKEXO2VT[data["order_type"]],
orderid=data["client_oid"],
direction=direction,
price=float(data["price"]),
volume=float(data["size"]),
traded=float(data["filled_qty"]),
datetime=generate_datetime(data["timestamp"]),
status=STATE_OKEXO2VT[data["state"]],
gateway_name=self.gateway_name,
)
self.gateway.on_order(copy(order))
trade_volume = data.get("last_fill_qty", 0)
if not trade_volume or float(trade_volume) == 0:
return
self.trade_count += 1
tradeid = f"{self.connect_time}{self.trade_count}"
trade = TradeData(
symbol=order.symbol,
exchange=order.exchange,
orderid=order.orderid,
tradeid=tradeid,
direction=order.direction,
offset=order.offset,
price=float(data["last_fill_px"]),
volume=float(trade_volume),
datetime=order.datetime,
gateway_name=self.gateway_name,
)
self.gateway.on_trade(trade)
def on_query_order(self, data: dict, request: Request) -> None:
""""""
key = (data["type"], data["timeInForce"])
order_type = ORDERTYPE_BINANCES2VT.get(key, None)
if not order_type:
return
order = OrderData(
orderid=data["clientOrderId"],
symbol=data["symbol"],
exchange=Exchange.BINANCE,
price=float(data["price"]),
volume=float(data["origQty"]),
type=order_type,
direction=DIRECTION_BINANCES2VT[data["side"]],
traded=float(data["executedQty"]),
status=STATUS_BINANCES2VT.get(data["status"], None),
datetime=generate_datetime(data["time"]),
gateway_name=self.gateway_name,
)
self.gateway.on_order(order)
self.gateway.write_log("订单信息查询成功")
def cross_stop_order(self):
"""
Cross stop order with last bar/tick data.
"""
if self.mode == BacktestingMode.BAR:
long_cross_price = self.bar.high_price
short_cross_price = self.bar.low_price
long_best_price = self.bar.open_price
short_best_price = self.bar.open_price
else:
long_cross_price = self.tick.last_price
short_cross_price = self.tick.last_price
long_best_price = long_cross_price
short_best_price = short_cross_price
for stop_order in list(self.active_stop_orders.values()):
# Check whether stop order can be triggered.
long_cross = (
stop_order.direction == Direction.LONG
and stop_order.price <= long_cross_price
)
short_cross = (
stop_order.direction == Direction.SHORT
and stop_order.price >= short_cross_price
)
if not long_cross and not short_cross:
continue
# Create order data.
self.limit_order_count += 1
order = OrderData(
symbol=self.symbol,
exchange=self.exchange,
orderid=str(self.limit_order_count),
direction=stop_order.direction,
offset=stop_order.offset,
price=stop_order.price,
volume=stop_order.volume,
traded=stop_order.volume,
status=Status.ALLTRADED,
gateway_name=self.gateway_name,
datetime=self.datetime
)
self.limit_orders[order.vt_orderid] = order
# Create trade data.
if long_cross:
trade_price = max(stop_order.price, long_best_price)
pos_change = order.volume
else:
trade_price = min(stop_order.price, short_best_price)
pos_change = -order.volume
self.trade_count += 1
trade = TradeData(
symbol=order.symbol,
exchange=order.exchange,
orderid=order.orderid,
tradeid=str(self.trade_count),
direction=order.direction,
offset=order.offset,
price=trade_price,
volume=order.volume,
datetime=self.datetime,
gateway_name=self.gateway_name,
)
self.trades[trade.vt_tradeid] = trade
# Update stop order.
stop_order.vt_orderids.append(order.vt_orderid)
stop_order.status = StopOrderStatus.TRIGGERED
if stop_order.stop_orderid in self.active_stop_orders:
self.active_stop_orders.pop(stop_order.stop_orderid)
# Push update to strategy.
self.strategy.on_stop_order(stop_order)
self.strategy.on_order(order)
self.strategy.pos += pos_change
self.strategy.on_trade(trade)
def on_order(self, order: OrderData):
""""""
if not order.is_active():
self.vt_orderid = ""
self.put_variables_event()
