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()