You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
355 lines
11 KiB
Python
355 lines
11 KiB
Python
from decimal import Decimal as D
|
|
|
|
from core.exchanges import GenericAPIError
|
|
from core.models import Account
|
|
from core.util import logs
|
|
|
|
log = logs.get_logger(__name__)
|
|
# Separate module to prevent circular import from
|
|
# models -> exchanges -> common -> models
|
|
# Since we need Account here to look up missing prices
|
|
|
|
|
|
def get_price(account, direction, symbol):
|
|
"""
|
|
Get the price for a given symbol.
|
|
:param account: Account object
|
|
:param direction: direction of the trade
|
|
:param symbol: symbol
|
|
:return: price of bid for buys, price of ask for sells
|
|
"""
|
|
if direction == "buy":
|
|
price_index = "bids"
|
|
elif direction == "sell":
|
|
price_index = "asks"
|
|
try:
|
|
prices = account.client.get_currencies([symbol])
|
|
except GenericAPIError as e:
|
|
log.error(f"Error getting currencies: {e}")
|
|
return None
|
|
price = D(prices["prices"][0][price_index][0]["price"])
|
|
return price
|
|
|
|
|
|
def side_to_direction(side, flip_direction=False):
|
|
"""
|
|
Convert a side to a direction.
|
|
:param side: Side, e.g. long, short
|
|
:param flip_direction: Flip the direction
|
|
:return: Direction, e.g. buy, sell
|
|
"""
|
|
if side == "long":
|
|
if flip_direction:
|
|
return "sell"
|
|
return "buy"
|
|
elif side == "short":
|
|
if flip_direction:
|
|
return "buy"
|
|
return "sell"
|
|
else:
|
|
return False
|
|
|
|
|
|
def direction_to_side(direction, flip_side=False):
|
|
"""
|
|
Convert a direction to a side.
|
|
:param direction: Direction, e.g. buy, sell
|
|
:param flip_side: Flip the side
|
|
:return: Side, e.g. long, short
|
|
"""
|
|
if direction == "buy":
|
|
if flip_side:
|
|
return "short"
|
|
return "long"
|
|
elif direction == "sell":
|
|
if flip_side:
|
|
return "long"
|
|
return "short"
|
|
else:
|
|
return False
|
|
|
|
|
|
def tp_price_to_percent(tp_price, side, current_price, current_units, unrealised_pl):
|
|
"""
|
|
Determine the percent change of the TP price from the initial price.
|
|
Positive values indicate a profit, negative values indicate a loss.
|
|
"""
|
|
pl_per_unit = D(unrealised_pl) / D(current_units)
|
|
if side == "long":
|
|
initial_price = D(current_price) - pl_per_unit
|
|
else:
|
|
initial_price = D(current_price) + pl_per_unit
|
|
# Get the percent change of the TP price from the initial price.
|
|
change_percent = ((initial_price - D(tp_price)) / initial_price) * 100
|
|
|
|
if side == "long":
|
|
if D(tp_price) < initial_price:
|
|
loss = True
|
|
else:
|
|
loss = False
|
|
else:
|
|
if D(tp_price) > initial_price:
|
|
loss = True
|
|
else:
|
|
loss = False
|
|
|
|
# if we are in loss on the short side, we want to show a negative
|
|
if loss:
|
|
change_percent = 0 - abs(change_percent)
|
|
else:
|
|
change_percent = abs(change_percent)
|
|
|
|
return round(change_percent, 5)
|
|
|
|
|
|
def tp_percent_to_price(tp_percent, side, current_price, current_units, unrealised_pl):
|
|
"""
|
|
Determine the price of the TP percent from the initial price.
|
|
Negative values for tp_percent indicate a loss.
|
|
"""
|
|
pl_per_unit = D(unrealised_pl) / D(current_units)
|
|
if side == "long":
|
|
initial_price = D(current_price) - pl_per_unit
|
|
else:
|
|
initial_price = D(current_price) + pl_per_unit
|
|
|
|
# Get the percent change of the TP price from the initial price.
|
|
change_percent = D(tp_percent) / 100
|
|
|
|
# Get the price of the TP percent from the initial price.
|
|
change_price = initial_price * abs(change_percent)
|
|
# loss is true if tp_percent is:
|
|
# - below initial_price for long
|
|
# - above initial_price for short
|
|
|
|
if D(tp_percent) < D(0):
|
|
loss = True
|
|
else:
|
|
loss = False
|
|
|
|
if side == "long":
|
|
if loss:
|
|
tp_price = D(initial_price) - change_price
|
|
else:
|
|
tp_price = D(initial_price) + change_price
|
|
else:
|
|
if loss:
|
|
tp_price = D(initial_price) + change_price
|
|
else:
|
|
tp_price = D(initial_price) - change_price
|
|
|
|
# if side == "long":
|
|
# tp_price = initial_price - change_price
|
|
# else:
|
|
# tp_price = initial_price + change_price
|
|
|
|
return round(tp_price, 5)
|
|
|
|
|
|
def sl_price_to_percent(sl_price, side, current_price, current_units, unrealised_pl):
|
|
"""
|
|
Determine the percent change of the SL price from the initial price.
|
|
Positive values indicate a loss, negative values indicate a profit.
|
|
This may seem backwards, but it is important to note that by default,
|
|
SL indicates a loss, and positive values should be expected.
|
|
Negative values indicate a negative loss, so a profit.
|
|
"""
|
|
|
|
pl_per_unit = D(unrealised_pl) / D(current_units)
|
|
if side == "long":
|
|
initial_price = D(current_price) - pl_per_unit
|
|
else:
|
|
initial_price = D(current_price) + pl_per_unit
|
|
|
|
# initial_price = D(current_price) - pl_per_unit
|
|
|
|
# Get the percent change of the SL price from the initial price.
|
|
change_percent = ((initial_price - D(sl_price)) / initial_price) * 100
|
|
|
|
# If the trade is long, the SL price will be higher than the initial price.
|
|
# if side == "long":
|
|
# change_percent *= -1
|
|
|
|
if side == "long":
|
|
if D(sl_price) > initial_price:
|
|
profit = True
|
|
else:
|
|
profit = False
|
|
else:
|
|
if D(sl_price) < initial_price:
|
|
profit = True
|
|
else:
|
|
profit = False
|
|
|
|
if profit:
|
|
change_percent = 0 - abs(change_percent)
|
|
else:
|
|
change_percent = abs(change_percent)
|
|
|
|
return round(change_percent, 5)
|
|
|
|
|
|
def sl_percent_to_price(sl_percent, side, current_price, current_units, unrealised_pl):
|
|
"""
|
|
Determine the price of the SL percent from the initial price.
|
|
"""
|
|
pl_per_unit = D(unrealised_pl) / D(current_units)
|
|
if side == "long":
|
|
initial_price = D(current_price) - pl_per_unit
|
|
else:
|
|
initial_price = D(current_price) + pl_per_unit
|
|
|
|
# Get the percent change of the SL price from the initial price.
|
|
change_percent = D(sl_percent) / 100
|
|
|
|
# Get the price of the SL percent from the initial price.
|
|
change_price = initial_price * abs(change_percent)
|
|
|
|
if D(sl_percent) < D(0):
|
|
profit = True
|
|
else:
|
|
profit = False
|
|
|
|
if side == "long":
|
|
if profit:
|
|
sl_price = D(initial_price) + change_price
|
|
else:
|
|
sl_price = D(initial_price) - change_price
|
|
else:
|
|
if profit:
|
|
sl_price = D(initial_price) - change_price
|
|
else:
|
|
sl_price = D(initial_price) + change_price
|
|
|
|
return round(sl_price, 5)
|
|
|
|
|
|
def annotate_trade_tp_sl_percent(trade):
|
|
"""
|
|
Annotate the trade with the TP and SL percent.
|
|
This works on Trade objects, which will require an additional market
|
|
lookup to get the current price.
|
|
"""
|
|
if "current_price" in trade:
|
|
current_price = trade["current_price"]
|
|
else:
|
|
account_id = trade["account_id"]
|
|
account = Account.get_by_id_no_user_check(account_id)
|
|
|
|
current_price = get_price(account, trade["direction"], trade["symbol"])
|
|
trade["current_price"] = current_price
|
|
|
|
current_units = trade["amount"]
|
|
if "pl" in trade:
|
|
unrealised_pl = trade["pl"]
|
|
else:
|
|
unrealised_pl = 0
|
|
|
|
if "side" in trade:
|
|
side = trade["side"]
|
|
direction = side_to_direction(side)
|
|
trade["direction"] = direction
|
|
else:
|
|
direction = trade["direction"]
|
|
side = direction_to_side(direction)
|
|
trade["side"] = side
|
|
|
|
if "take_profit" in trade:
|
|
if trade["take_profit"]:
|
|
take_profit = trade["take_profit"]
|
|
take_profit_percent = tp_price_to_percent(
|
|
take_profit, trade["side"], current_price, current_units, unrealised_pl
|
|
)
|
|
|
|
trade["take_profit_percent"] = take_profit_percent
|
|
|
|
if "stop_loss" in trade:
|
|
if trade["stop_loss"]:
|
|
stop_loss = trade["stop_loss"]
|
|
stop_loss_percent = sl_price_to_percent(
|
|
stop_loss, side, current_price, current_units, unrealised_pl
|
|
)
|
|
|
|
trade["stop_loss_percent"] = stop_loss_percent
|
|
|
|
if "trailing_stop_loss" in trade:
|
|
if trade["trailing_stop_loss"]:
|
|
trailing_stop_loss = trade["trailing_stop_loss"]
|
|
trailing_stop_loss_percent = sl_price_to_percent(
|
|
trailing_stop_loss,
|
|
trade["side"],
|
|
current_price,
|
|
current_units,
|
|
unrealised_pl,
|
|
)
|
|
|
|
trade["trailing_stop_loss_percent"] = trailing_stop_loss_percent
|
|
|
|
return trade
|
|
|
|
|
|
def open_trade_to_unified_format(trade):
|
|
"""
|
|
Convert an open trade to a Trade-like format.
|
|
"""
|
|
current_price = trade["price"]
|
|
current_units = trade["currentUnits"]
|
|
unrealised_pl = trade["unrealizedPL"]
|
|
side = trade["side"]
|
|
cast = {
|
|
"id": trade["id"],
|
|
"symbol": trade["symbol"],
|
|
"amount": current_units,
|
|
# For crossfilter
|
|
"units": current_units,
|
|
"side": side,
|
|
"direction": side_to_direction(side),
|
|
"state": trade["state"],
|
|
"current_price": current_price,
|
|
"pl": unrealised_pl,
|
|
}
|
|
if "openTime" in trade:
|
|
cast["open_time"] = trade["openTime"]
|
|
# Add some extra fields, sometimes we have already looked up the
|
|
# prices and don't need to call convert_trades_to_usd
|
|
# This is mostly for tests, but it can be useful in other places.
|
|
if "take_profit_usd" in trade:
|
|
cast["take_profit_usd"] = trade["take_profit_usd"]
|
|
if "stop_loss_usd" in trade:
|
|
cast["stop_loss_usd"] = trade["stop_loss_usd"]
|
|
if "trailing_stop_loss_usd" in trade:
|
|
cast["trailing_stop_loss_usd"] = trade["trailing_stop_loss_usd"]
|
|
if "takeProfitOrder" in trade:
|
|
if trade["takeProfitOrder"]:
|
|
take_profit = trade["takeProfitOrder"]["price"]
|
|
cast["take_profit"] = take_profit
|
|
|
|
if "stopLossOrder" in trade:
|
|
if trade["stopLossOrder"]:
|
|
stop_loss = trade["stopLossOrder"]["price"]
|
|
cast["stop_loss"] = stop_loss
|
|
|
|
if "trailingStopLossOrder" in trade:
|
|
if trade["trailingStopLossOrder"]:
|
|
trailing_stop_loss = trade["trailingStopLossOrder"]["price"]
|
|
cast["trailing_stop_loss"] = trailing_stop_loss
|
|
|
|
return cast
|
|
|
|
|
|
def convert_trades(open_trades):
|
|
"""
|
|
Convert a list of open trades into a list of Trade-like objects.
|
|
"""
|
|
trades = []
|
|
for trade in open_trades:
|
|
if "currentUnits" in trade: # Open trade
|
|
cast = open_trade_to_unified_format(trade)
|
|
cast = annotate_trade_tp_sl_percent(cast)
|
|
trades.append(cast)
|
|
else:
|
|
cast = annotate_trade_tp_sl_percent(trade)
|
|
trades.append(cast)
|
|
|
|
return trades
|