def modify_take_profit(self, trader, market_id, limit_price):
if self.limit_oid:
# cancel the limit order and create a new one
if trader.cancel_order(self.limit_oid):
self.limit_ref_oid = None
self.limit_oid = None
self.limit_order_qty = 0.0
else:
return False
if self.e == self.x:
# all entry qty is filled
return True
if self.e < self.x:
# something wrong but its ok
return False
if self.position_id:
# if not accepted as modification do it as limit order
if trader.modify_position(self.position_id,
take_profit_price=limit_price):
self.tp = limit_price
return True
elif self.e > 0:
# only if filled entry partially or totally
order = Order(self, market_id)
order.direction = -self.direction
order.order_type = Order.ORDER_LIMIT
order.reduce_only = True
order.quantity = self.e - self.x # remaining
order.price = limit_price
trader.set_ref_order_id(order)
self.limit_ref_oid = order.ref_order_id
self._stats['exit-maker'] = not order.is_market()
if trader.create_order(order):
self.limit_oid = order.order_id
self.limit_order_qty = order.quantity
self.last_tp_ot[0] = order.created_time
self.last_tp_ot[1] += 1
self.tp = limit_price
return True
else:
self.limit_ref_oid = None
self.limit_order_qty = 0.0
return False
def close(self, trader, market_id):
"""
Close the position and cancel the related orders.
"""
if self._closing:
# already closing order
return False
if self.create_oid:
# cancel the remaining buy order
if trader.cancel_order(self.create_oid):
self.create_ref_oid = None
self.create_oid = None
self._entry_state = StrategyTrade.STATE_CANCELED
if self.stop_oid:
# cancel the stop order
if trader.cancel_order(self.stop_oid):
self.stop_ref_oid = None
self.stop_oid = None
if self.limit_oid:
# cancel the limit order
if trader.cancel_order(self.limit_oid):
self.limit_ref_oid = None
self.limit_oid = None
if self.e - self.x > 0.0:
order = Order(trader, market_id)
order.direction = -self.dir # neg dir
order.order_type = Order.ORDER_MARKET
order.reduce_only = True
order.quantity = self.e - self.x # remaining qty
# generated a reference order id
trader.set_ref_order_id(order)
self.stop_ref_oid = order.ref_order_id
self._stats['exit-maker'] = not order.is_market()
if trader.create_order(order):
self.stop_oid = order.order_id
self.stop_order_qty = order.quantity
# closing order defined
self._closing = True
return True
else:
self.stop_ref_oid = None
return False
return True
def open(self,
trader,
market_id,
direction,
order_type,
order_price,
quantity,
take_profit,
stop_loss,
leverage=1.0,
hedging=None):
"""
Open a position or buy an asset.
@param hedging If defined use the defined value else use the default from the market.
"""
order = Order(trader, market_id)
order.direction = direction
order.price = order_price
order.order_type = order_type
order.quantity = quantity
order.leverage = leverage
order.post_only = False
if hedging:
order.hedging = hedging
# generated a reference order id
trader.set_ref_order_id(order)
self.create_ref_oid = order.ref_order_id
self.dir = order.direction
self.op = order.price # retains the order price
self.oq = order.quantity # ordered quantity
self.tp = take_profit
self.sl = stop_loss
self._stats['entry-maker'] = not order.is_market()
if trader.create_order(order):
# keep the related create position identifier if available
self.position_id = order.position_id
if not self.eot and order.created_time:
# only at the first open
self.eot = order.created_time
return True
else:
self._entry_state = StrategyTrade.STATE_REJECTED
return False
def open(self,
trader,
market_id,
direction,
order_type,
order_price,
quantity,
take_profit,
stop_loss,
leverage=1.0,
hedging=None):
"""
Buy an asset.
"""
if self._entry_state != StrategyTrade.STATE_NEW:
return False
order = Order(trader, market_id)
order.direction = direction
order.price = order_price
order.order_type = order_type
order.quantity = quantity
order.leverage = leverage
# if need to retry @todo or cancel
# self._market_id = market_id
# self._order_type = order_type
# self._leverage = leverage
# generated a reference order id
trader.set_ref_order_id(order)
self.entry_ref_oid = order.ref_order_id
self.dir = order.direction
self.op = order.price # retains the order price
self.oq = order.quantity # ordered quantity
self.tp = take_profit
self.sl = stop_loss
self._stats['entry-maker'] = not order.is_market()
if trader.create_order(order):
if not self.eot and order.created_time:
# only at the first open
self.eot = order.created_time
return True
else:
self._entry_state = StrategyTrade.STATE_REJECTED
return False
def close(self, trader, market_id):
if self.sell_ref_oid:
logger.error("Trade %s has already ordered an exit !" % self.id)
return False
if self.buy_oid:
# cancel the remaining buy order
if trader.cancel_order(self.sell_oid):
self.buy_ref_oid = None
self.buy_oid = None
self._entry_state = StrategyTrade.STATE_CANCELED
if self.sell_oid:
# cancel the sell order and create a new one
if trader.cancel_order(self.sell_oid):
self.sell_ref_oid = None
self.sell_oid = None
self.sell_order_type = Order.ORDER_MARKET
self.sell_order_qty = 0.0
self._exit_state = StrategyTrade.STATE_CANCELED
if self.e == self.x:
# all entry qty is filled
return True
if self.e < self.x:
# something wrong but its ok
return False
order = Order(trader, market_id)
order.direction = -self.dir # neg dir
order.order_type = Order.ORDER_MARKET
order.quantity = self.e - self.x # remaining qty
self._stats['exit-maker'] = not order.is_market()
# generated a reference order id and keep it before ordering to retrieve its signals
trader.set_ref_order_id(order)
self.sell_ref_oid = order.ref_order_id
if trader.create_order(order):
self.sell_order_type = order.order_type
self.sell_order_qty = order.quantity
return True
else:
# rejected
self.sell_ref_oid = None
return False
def close(self, trader, market_id):
"""
Close the position and cancel the related orders.
"""
if self.create_oid:
# cancel the remaining buy order
if trader.cancel_order(self.create_oid):
self.create_ref_oid = None
self.create_oid = None
self._entry_state = StrategyTrade.STATE_CANCELED
if self.stop_oid:
# cancel the stop order
if trader.cancel_order(self.stop_oid):
self.stop_ref_oid = None
self.stop_oid = None
if self.limit_oid:
# cancel the limit order
if trader.cancel_order(self.limit_oid):
self.limit_ref_oid = None
if self.e == self.x:
# all entry qty is filled
return True
if self.e < self.x:
# something wrong but its ok
return False
order = Order(trader, market_id)
order.direction = -self.dir # neg dir
order.order_type = Order.ORDER_MARKET
order.quantity = self.e - self.x # remaining qty
# generated a reference order id
trader.set_ref_order_id(order)
self.stop_ref_oid = order.ref_order_id
self._stats['exit-maker'] = not order.is_market()
if trader.create_order(order):
return True
else:
self.stop_ref_oid = None
return False
return True
def modify_stop_loss(self, trader, market_id, price):
if self.stop_oid:
# cancel the stop order and create a new one
if trader.cancel_order(self.stop_oid):
self.stop_ref_oid = None
self.stop_oid = None
else:
return False
if self.e == self.x:
# all entry qty is filled
return True
if self.e < self.x:
# something wrong but its ok
return False
if self.position_id:
# if not accepted as modification do it as stop order
if trader.modify_position(self.position_id, stop_loss_price=price):
self.sl = price
return True
elif self.e > 0:
# only if filled entry partially or totally
order = Order(self, market_id)
order.direction = self.direction
order.order_type = Order.ORDER_STOP
order.reduce_only = True
order.quantity = self.e - self.x # remaining
order.order_price = price
trader.set_ref_order_id(order)
self.stop_ref_oid = order.ref_order_id
self._stats['exit-maker'] = not order.is_market()
if trader.create_order(order):
self.stop_oid = order.order_id
self.stop_order_qty = order.quantity
self.sl = price
return True
else:
self.stop_ref_oid = None
self.stop_order_qty = 0.0
return False
def open(self,
trader,
market_id,
direction,
order_type,
order_price,
quantity,
take_profit,
stop_loss,
leverage=1.0,
hedging=None):
"""
Open a position or buy an asset.
"""
order = Order(trader, market_id)
order.direction = direction
order.price = order_price
order.order_type = order_type
order.quantity = quantity
order.leverage = leverage
order.post_only = False
# generated a reference order id
trader.set_ref_order_id(order)
self.create_ref_oid = order.ref_order_id
self.dir = order.direction
self.op = order.price # retains the order price
self.oq = order.quantity # ordered quantity
self.tp = take_profit
self.sl = stop_loss
self._stats['entry-maker'] = not order.is_market()
if trader.create_order(order):
self.position_id = order.position_id # might be market-id
if not self.eot and order.created_time:
self.eot = order.created_time
return True
else:
self._entry_state = StrategyTrade.STATE_REJECTED
return False
def modify_take_profit(self, trader, market_id, price):
if self.limit_oid:
# cancel the limit order and create a new one
if trader.cancel_order(self.limit_oid):
self.limit_ref_oid = None
self.limit_oid = None
self.limit_order_qty = 0.0
else:
return False
if self.e == self.x:
# all entry qty is filled
return True
if self.e < self.x:
# something wrong but its ok
return False
if self.e > 0:
# only if filled entry partially or totally
order = Order(self, market_id)
order.direction = self.direction
order.order_type = Order.ORDER_TAKE_PROFIT_LIMIT
# order.reduce_only = True (not for now because it implies to have the filled qty, and so need to update each time trade qty is updated)
order.quantity = self.e - self.x # remaining
order.order_price = price
trader.set_ref_order_id(order)
self.limit_ref_oid = order.ref_order_id
self._stats['exit-maker'] = not order.is_market()
if trader.create_order(order):
self.limit_oid = order.order_id
self.limit_order_qty = order.quantity
self.tp = price
return True
else:
self.limit_ref_oid = None
self.limit_order_qty = 0.0
return False
def modify_stop_loss(self, trader, market_id, price):
self.sl = price
if self.sell_oid:
# cancel the sell order and create a new one
if trader.cancel_order(self.sell_oid):
# returns true, no need to wait signal confirmation
self.sell_ref_oid = None
self.sell_oid = None
self.sell_order_type = Order.ORDER_MARKET
self.sell_order_qty = 0.0
self._exit_state = StrategyTrade.STATE_DELETED
if self.e == self.x:
# all entry qty is filled
return True
if self.e < self.x:
# something wrong but its ok
return False
if price:
order = Order(trader, market_id)
order.direction = -self.dir # neg dir
order.order_type = Order.ORDER_STOP
order.quantity = self.e - self.x # remaining
self._stats['exit-maker'] = not order.is_market()
# generated a reference order id
trader.set_ref_order_id(order)
self.sell_ref_oid = order.ref_order_id
if trader.create_order(order):
self.sell_order_type = order.order_type
self.sell_order_qty = order.quantity
return True
else:
return False
return True
def modify_take_profit(self, trader, market_id, limit_price):
if self.limit_oid:
# cancel the limit order and create a new one
if trader.cancel_order(self.limit_oid):
self.limit_ref_oid = None
self.limit_oid = None
self.limit_order_qty = 0.0
else:
return False
if self.e - self.x > 0.0:
# only if filled entry partially or totally
order = Order(self, market_id)
order.direction = -self.direction
order.order_type = Order.ORDER_LIMIT
order.reduce_only = True # (not for now because it implies to have the filled qty, and so need to update each time trade qty is updated)
order.quantity = self.e - self.x # remaining
order.price = limit_price
trader.set_ref_order_id(order)
self.limit_ref_oid = order.ref_order_id
self._stats['exit-maker'] = not order.is_market()
if trader.create_order(order):
self.limit_oid = order.order_id
self.limit_order_qty = order.quantity
self.last_tp_ot[0] = order.created_time
self.last_tp_ot[1] += 1
self.tp = limit_price
return True
else:
self.limit_ref_oid = None
self.limit_order_qty = 0.0
return False
def modify_stop_loss(self, trader, market_id, stop_price):
if self.stop_oid:
# cancel the stop order and create a new one
if trader.cancel_order(self.stop_oid):
self.stop_ref_oid = None
self.stop_oid = None
else:
return False
if self.e - self.x > 0.0:
# only if filled entry partially or totally
order = Order(self, market_id)
order.direction = -self.direction
order.order_type = Order.ORDER_STOP
order.reduce_only = True
order.quantity = self.e - self.x # remaining
order.stop_price = stop_price
trader.set_ref_order_id(order)
self.stop_ref_oid = order.ref_order_id
self._stats['exit-maker'] = not order.is_market()
if trader.create_order(order):
self.stop_oid = order.order_id
self.stop_order_qty = order.quantity
self.last_sl_ot[0] = order.created_time
self.last_sl_ot[1] += 1
self.sl = stop_price
return True
else:
self.stop_ref_oid = None
self.stop_order_qty = 0.0
return False
def close(self, trader, market_id):
if self._closing:
# already closing order
return False
if self.oco_oid:
# @todo cancel OCO order and create an order market
return False
else:
# if self.stop_ref_oid:
# logger.error("Trade %s has already ordered an exit !" % self.id)
# return False
if self.entry_oid:
# cancel the remaining buy order
if trader.cancel_order(self.entry_oid):
self.entry_ref_oid = None
self.entry_oid = None
if self.limit_oid:
# cancel the sell limit order
if trader.cancel_order(self.limit_oid):
self.limit_ref_oid = None
self.limit_oid = None
self.limit_order_type = Order.ORDER_MARKET
self.limit_order_qty = 0.0
if self.stop_oid:
# cancel the sell stop order and create a new one
if trader.cancel_order(self.stop_oid):
self.stop_ref_oid = None
self.stop_oid = None
self.stop_order_type = Order.ORDER_MARKET
self.stop_order_qty = 0.0
if self.x >= self.e:
# all qty is filled
return True
order = Order(trader, market_id)
order.direction = -self.dir # neg dir
order.order_type = Order.ORDER_MARKET
order.quantity = self.e - self.x # remaining qty
self._stats['exit-maker'] = not order.is_market()
# generated a reference order id and keep it before ordering to retrieve its signals
trader.set_ref_order_id(order)
self.stop_ref_oid = order.ref_order_id
if trader.create_order(order):
self.stop_order_type = order.order_type
self.stop_order_qty = order.quantity
# closing order defined
self._closing = True
return True
else:
# rejected
self.stop_ref_oid = None
return False
def modify_stop_loss(self, trader, market_id, stop_price):
if self._closing:
# already closing order
return False
if self._exit_state == StrategyTrade.STATE_FILLED:
# exit already fully filled
return False
if self.oco_oid:
# @todo need recreate stop and limit OCO order
return False
else:
if self.stop_oid:
# cancel the sell stop order and create a new one
if trader.cancel_order(self.stop_oid):
# REST sync
# returns true, no need to wait signal confirmation
self.stop_ref_oid = None
self.stop_oid = None
self.stop_order_type = Order.ORDER_MARKET
self.stop_order_qty = 0.0
if self.limit_oid:
# cancel the sell limit order (only one or the other)
if trader.cancel_order(self.limit_oid):
# REST sync
# returns true, no need to wait signal confirmation
self.limit_ref_oid = None
self.limit_oid = None
self.limit_order_type = Order.ORDER_MARKET
self.limit_order_qty = 0.0
if self.x >= self.e:
# all entry qty is filled
return True
if stop_price:
order = Order(trader, market_id)
order.direction = -self.dir # neg dir
order.order_type = Order.ORDER_STOP
order.stop_price = stop_price
order.quantity = self.e - self.x # remaining
# @todo not correct, depend of what is executed
self._stats['exit-maker'] = not order.is_market()
# generated a reference order id
trader.set_ref_order_id(order)
self.stop_ref_oid = order.ref_order_id
if trader.create_order(order):
# REST sync
self.stop_order_type = order.order_type
self.stop_order_qty = order.quantity
self.last_sl_ot[0] = order.created_time
self.last_sl_ot[1] += 1
self.sl = stop_price
return True
else:
# rejected
self.stop_ref_oid = None
return False
return True
def close(self, trader, market_id):
"""
Close the position and cancel the related orders.
"""
if self._closing:
# already closing order
return False
if self.create_oid:
# cancel the remaining buy order
if trader.cancel_order(self.create_oid):
self.create_ref_oid = None
self.create_oid = None
self._entry_state = StrategyTrade.STATE_CANCELED
if self.stop_oid:
# cancel the stop order
if trader.cancel_order(self.stop_oid):
self.stop_ref_oid = None
self.stop_oid = None
if self.limit_oid:
# cancel the limit order
if trader.cancel_order(self.limit_oid):
self.limit_ref_oid = None
if self.position_id:
# most of the margin broker case we have a position id
if self._exit_state != StrategyTrade.STATE_PARTIALLY_FILLED:
if trader.close_position(self.position_id):
return True
else:
return False
elif self.e - self.x > 0.0:
# bitmex case no have position id
order = Order(trader, market_id)
order.direction = -self.dir # neg dir
order.order_type = Order.ORDER_MARKET
order.quantity = self.e - self.x # remaining qty
# generated a reference order id
trader.set_ref_order_id(order)
self.stop_ref_oid = order.ref_order_id
self._stats['exit-maker'] = not order.is_market()
if trader.create_order(order):
self.stop_oid = order.order_id
self.stop_order_qty = order.quantity
# closing order defined
self._closing = True
return True
else:
self.stop_ref_oid = None
return False
return True
