def create_from_start_amount(cls,
symbol,
start_currency,
amount_start,
dest_currency,
price,
cancel_threshold: float = 0.000001,
max_order_updates: int = 10):
side = core.get_order_type(start_currency, dest_currency, symbol)
if not side:
raise errors.OrderError("Wrong symbol {} for trade {} - {}".format(
symbol, start_currency, dest_currency))
if price <= 0:
raise errors.OrderError(
"Wrong price. Symbol: {}, Side:{}, Price:{} ".format(
symbol, side, price))
if side == "sell":
amount = amount_start
elif side == "buy":
amount = amount_start / price
owa_order = cls(symbol, amount, price, side, cancel_threshold,
max_order_updates)
return owa_order
def _create_next_trade_order_for_remained_amount(self, price):
"""
creates the next trade order for unfilled amount of Action order
:param price: price of the new order
:return:
"""
amount = self.start_amount - self.filled_start_amount
if amount <= 0:
raise errors.OrderError("Bad new order amount {}".format(amount))
order_params = (self.symbol, self.start_currency, amount,
self.dest_currency, price)
if False not in order_params:
# self.price = price
order = TradeOrder.create_limit_order_from_start_amount(
*order_params) # type: TradeOrder
order.supplementary.update(
{"parent_action_order": {
"state": self.state
}})
return order
else:
raise errors.OrderError("Not all parameters for Order are set")
def __init__(self,
symbol,
amount: float,
price: float,
side: str,
cancel_threshold: float = 0.000001,
max_order_updates: int = 10):
if price is None or price <= 0:
raise errors.OrderError("Wrong price {}".format(price))
self.id = str(uuid.uuid4()) # internal ID
self.timestamp = time.time() # timestamp of object creation
self.timestamp_close = float()
# Generic order Parameters
self.symbol = symbol
self.amount = amount
self.price = price
self.side = side
self.cancel_threshold = cancel_threshold # do not cancel if less than this threshold
self.status = "new" # new, open, closed
self.filled_dest_amount = 0.0
self.filled_start_amount = 0.0
self.filled_price = 0.0
self.filled = 0.0 # filled amount of base currency
self.max_order_updates = max_order_updates # max amount of order updates
self.order_command = None # None, new, cancel
self.active_trade_order = None
self.orders_history = list() # type: List[TradeOrder]
self.market_data = list(
) # list of data received by via order commands
self._prev_filled_dest_amount = 0.0 # filled amounts on previous orders
self._prev_filled_start_amount = 0.0 # filled amountsbot, on previous orders
self._prev_filled = 0.0 # filled amounts on previous orders
# create initial trade order
self.active_trade_order = self._create_initial_trade_order(
) # type: TradeOrder
# different tags for additional information
self.tags = list()
self._force_close = False
"""
flag to force ActionOrder closing. Means to cancel current trade order and finalize
"""
# init the global parameters of order and state
self._init()
def _get_recovery_price_for_best_dest_amount(self):
"""
:return: price for recovery order from target_amount and target_currency without fee
"""
if self.best_dest_amount == 0 or self.start_amount == 0:
raise errors.OrderError(
"RecoveryManagerError: Zero start ot dest amount")
if self.symbol is None:
raise errors.OrderError("RecoveryManagerError: Symbol is not set")
if self.side is None:
raise errors.OrderError("RecoveryManagerError: Side not set")
if self.side == "buy":
return self.start_amount / self.best_dest_amount
if self.side == "sell":
return self.best_dest_amount / self.start_amount
return False
def _init_market_price(self):
try:
price = self.market_data[self.symbol]["price"][self.side]
except Exception:
raise errors.OrderError("Could not set price from market data")
self.status = "open"
self.state = "market_price"
self.order_command = "new"
self.active_trade_order = self._create_recovery_order(
price, self.state)
def _create_recovery_order(self, price, state: str):
amount = self.start_amount - self.filled_start_amount
if amount <= 0:
raise errors.OrderError("Bad new order amount {}".format(amount))
order_params = (self.symbol, self.start_currency, amount,
self.dest_currency, price)
if False not in order_params:
self.price = price
order = TradeOrder.create_limit_order_from_start_amount(
*order_params) # type: TradeOrder
order.supplementary.update(
{"parent_action_order": {
"state": state
}})
return order
else:
raise errors.OrderError("Not all parameters for Order are set")
def _close_active_order(self):
if self.active_trade_order.status == "closed" or self.active_trade_order.status == "canceled":
self.orders_history.append(copy.copy(self.active_trade_order))
self.active_trade_order = None
self.order_command = ""
self._prev_filled = copy.copy(self.filled)
self._prev_filled_start_amount = copy.copy(
self.filled_start_amount)
self._prev_filled_dest_amount = copy.copy(self.filled_dest_amount)
else:
raise errors.OrderError(
"Active Trade order is not closed {}".format(
self.active_trade_order.status))