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.
556 lines
20 KiB
Python
556 lines
20 KiB
Python
from datetime import datetime
|
|
from decimal import Decimal as D
|
|
|
|
from core.exchanges import common
|
|
from core.exchanges.convert import get_price, side_to_direction
|
|
from core.lib.notify import sendmsg
|
|
from core.models import Account, Strategy, Trade
|
|
from core.trading import assetfilter, checks
|
|
from core.trading.crossfilter import crossfilter
|
|
from core.trading.risk import check_risk
|
|
from core.util import logs
|
|
|
|
log = logs.get_logger(__name__)
|
|
|
|
|
|
def convert_trades_to_usd(account, trades):
|
|
"""
|
|
Convert a list of trades to USD. Input will also be mutated.
|
|
:param account: Account object
|
|
:param trades: List of trades
|
|
:return: List of trades, with amount_usd added
|
|
"""
|
|
for trade in trades:
|
|
amount = trade["amount"]
|
|
symbol = trade["symbol"]
|
|
side = trade["side"]
|
|
direction = side_to_direction(side)
|
|
base, quote = get_base_quote(account.exchange, symbol)
|
|
amount_usd = common.to_currency(direction, account, amount, base, "USD")
|
|
trade["trade_amount_usd"] = amount_usd
|
|
if "stop_loss_percent" in trade:
|
|
trade["stop_loss_usd"] = (trade["stop_loss_percent"] / 100) * amount_usd
|
|
if "take_profit_percent" in trade:
|
|
trade["take_profit_usd"] = (trade["take_profit_percent"] / 100) * amount_usd
|
|
if "trailing_stop_loss_percent" in trade:
|
|
trade["trailing_stop_loss_usd"] = (
|
|
trade["trailing_stop_loss_percent"] / 100
|
|
) * amount_usd
|
|
|
|
return trades
|
|
|
|
|
|
def get_base_quote(exchange, symbol):
|
|
"""
|
|
Get the base and quote currencies from a symbol.
|
|
:param exchange: Exchange name
|
|
:param symbol: Symbol
|
|
:return: Tuple of base and quote currencies
|
|
"""
|
|
if exchange == "alpaca":
|
|
separator = "/"
|
|
elif exchange == "oanda":
|
|
separator = "_"
|
|
base, quote = symbol.split(separator)
|
|
return (base, quote)
|
|
|
|
|
|
def get_trade_size_in_base(direction, account, strategy, cash_balance, base):
|
|
"""
|
|
Get the trade size in the base currency.
|
|
:param direction: Direction of the trade
|
|
:param account: Account object
|
|
:param strategy: Strategy object
|
|
:param cash_balance: Cash balance in the Account's base currency
|
|
:param base: Base currency
|
|
:return: Trade size in the base currency
|
|
"""
|
|
|
|
# Convert the trade size in percent to a ratio
|
|
trade_size_as_ratio = D(strategy.order_settings.trade_size_percent) / D(100)
|
|
log.debug(f"Trade size as ratio: {trade_size_as_ratio}")
|
|
|
|
# Multiply with cash balance to get the trade size in the account's
|
|
# base currency
|
|
amount_fiat = D(trade_size_as_ratio) * D(cash_balance)
|
|
log.debug(f"Trade size: {amount_fiat}")
|
|
|
|
# Convert the trade size to the base currency
|
|
if account.currency.lower() == base.lower():
|
|
trade_size_in_base = amount_fiat
|
|
else:
|
|
trade_size_in_base = common.to_currency(
|
|
direction, account, amount_fiat, account.currency, base
|
|
)
|
|
log.debug(f"Trade size in base: {trade_size_in_base}")
|
|
|
|
return trade_size_in_base
|
|
|
|
|
|
def get_tp(direction, take_profit_percent, price):
|
|
"""
|
|
Get the take profit price.
|
|
:param direction: Direction of the trade
|
|
:param strategy: Strategy object
|
|
:param price: Entry price
|
|
"""
|
|
# Convert to ratio
|
|
take_profit_as_ratio = D(take_profit_percent) / D(100)
|
|
log.debug(f"Take profit as ratio: {take_profit_as_ratio}")
|
|
|
|
take_profit_var = D(price) * D(take_profit_as_ratio)
|
|
log.debug(f"Take profit var: {take_profit_var}")
|
|
|
|
if direction == "buy":
|
|
take_profit = D(price) + D(take_profit_var)
|
|
elif direction == "sell":
|
|
take_profit = D(price) - D(take_profit_var)
|
|
|
|
log.debug(f"Take profit: {take_profit}")
|
|
return take_profit
|
|
|
|
|
|
def get_sl(direction, stop_loss_percent, price, return_var=False):
|
|
"""
|
|
Get the stop loss price.
|
|
Also used for trailing stop loss.
|
|
:param direction: Direction of the trade
|
|
:param strategy: Strategy object
|
|
:param price: Entry price
|
|
"""
|
|
# Convert to ratio
|
|
stop_loss_as_ratio = D(stop_loss_percent) / D(100)
|
|
log.debug(f"Stop loss as ratio: {stop_loss_as_ratio}")
|
|
|
|
stop_loss_var = D(price) * D(stop_loss_as_ratio)
|
|
log.debug(f"Stop loss var: {stop_loss_var}")
|
|
|
|
if return_var:
|
|
return stop_loss_var
|
|
|
|
if direction == "buy":
|
|
stop_loss = D(price) - D(stop_loss_var)
|
|
elif direction == "sell":
|
|
stop_loss = D(price) + D(stop_loss_var)
|
|
|
|
log.debug(f"Stop loss: {stop_loss}")
|
|
return stop_loss
|
|
|
|
|
|
def get_tp_sl(direction, strategy, price, round_to=None):
|
|
"""
|
|
Get the take profit and stop loss prices.
|
|
:param direction: Direction of the trade
|
|
:param strategy: Strategy object
|
|
:param price: Price of the trade
|
|
:return: Take profit and stop loss prices
|
|
"""
|
|
cast = {}
|
|
if strategy.order_settings.take_profit_percent != 0:
|
|
cast["take_profit"] = get_tp(
|
|
direction, strategy.order_settings.take_profit_percent, price
|
|
)
|
|
|
|
if strategy.order_settings.stop_loss_percent != 0:
|
|
cast["stop_loss"] = get_sl(
|
|
direction, strategy.order_settings.stop_loss_percent, price
|
|
)
|
|
|
|
# Look up the TSL if required by the strategy
|
|
if strategy.order_settings.trailing_stop_loss_percent != 0:
|
|
cast["trailing_stop_loss"] = get_sl(
|
|
direction,
|
|
strategy.order_settings.trailing_stop_loss_percent,
|
|
price,
|
|
return_var=True,
|
|
)
|
|
|
|
if round_to:
|
|
for key in cast:
|
|
cast[key] = float(round(cast[key], round_to))
|
|
|
|
return cast
|
|
|
|
|
|
def get_price_bound(direction, strategy, price, current_price):
|
|
"""
|
|
Get the price bound for a given price using the slippage from the strategy.
|
|
* Check that the price of the callback is within the callback price deviation of the
|
|
current price
|
|
* Calculate the price bounds such that the maximum slippage should be within the
|
|
price slippage relative to the current price.
|
|
Note that the maximum actual slippage may be as high as the sum of these two values.
|
|
:param direction: Direction of the trade
|
|
:param strategy: Strategy object
|
|
:param price: Price of the trade
|
|
:param current_price: current price from the exchange
|
|
:return: Price bound
|
|
"""
|
|
|
|
# Convert the callback price deviation to a ratio
|
|
if strategy.risk_model is not None:
|
|
callback_price_deviation_as_ratio = D(
|
|
strategy.risk_model.callback_price_deviation_percent
|
|
) / D(100)
|
|
else:
|
|
callback_price_deviation_as_ratio = D(0.5) / D(100)
|
|
log.debug(f"Callback price deviation as ratio: {callback_price_deviation_as_ratio}")
|
|
|
|
maximum_price_deviation = D(current_price) * D(callback_price_deviation_as_ratio)
|
|
|
|
# Ensure the current price is within price_slippage_as_ratio of the callback price
|
|
if abs(current_price - price) <= maximum_price_deviation:
|
|
log.debug("Current price is within price deviation of callback price")
|
|
else:
|
|
log.error("Current price is not within price deviation of callback price")
|
|
log.debug(f"Difference: {abs(current_price - price)}")
|
|
return None
|
|
|
|
# Convert the maximum price slippage to a ratio
|
|
if strategy.risk_model is not None:
|
|
price_slippage_as_ratio = D(strategy.risk_model.price_slippage_percent) / D(100)
|
|
else:
|
|
# Pretty liberal default
|
|
price_slippage_as_ratio = D(2.5) / D(100)
|
|
log.debug(f"Maximum price slippage as ratio: {price_slippage_as_ratio}")
|
|
|
|
# Calculate the price bound by multiplying with the price
|
|
# The price bound is the worst price we are willing to pay for the trade
|
|
price_slippage = D(current_price) * D(price_slippage_as_ratio)
|
|
log.debug(f"Maximum deviation from callback price: {price_slippage}")
|
|
|
|
current_price_slippage = D(current_price) * D(price_slippage_as_ratio)
|
|
log.debug(f"Maximum deviation from current price: {current_price_slippage}")
|
|
|
|
# Price bound is the worst price we are willing to pay for the trade
|
|
# For buys, a higher price is worse
|
|
if direction == "buy":
|
|
price_bound = D(current_price) + D(price_slippage)
|
|
|
|
# For sells, a lower price is worse
|
|
elif direction == "sell":
|
|
price_bound = D(current_price) - D(price_slippage)
|
|
|
|
log.debug(f"Price bound: {price_bound}")
|
|
return price_bound
|
|
|
|
|
|
def get_precision(account, symbol):
|
|
instruments = account.instruments
|
|
if not instruments:
|
|
log.error(f"No instruments found for {account}")
|
|
sendmsg(account.user, f"No instruments found for {account}", title="Error")
|
|
return (None, None)
|
|
# Extract the information for the symbol
|
|
instrument = account.client.extract_instrument(instruments, symbol)
|
|
if not instrument:
|
|
sendmsg(account.user, f"Symbol not found: {symbol}", title="Error")
|
|
log.error(f"Symbol not found: {symbol}")
|
|
return (None, None)
|
|
# Get the required precision
|
|
try:
|
|
trade_precision = instrument["tradeUnitsPrecision"]
|
|
display_precision = instrument["displayPrecision"]
|
|
return (trade_precision, display_precision)
|
|
except KeyError:
|
|
sendmsg(
|
|
account.user,
|
|
f"Precision not found for {symbol} from {instrument}",
|
|
title="Error",
|
|
)
|
|
log.error(f"Precision not found for {symbol} from {instrument}")
|
|
return (None, None)
|
|
|
|
|
|
# TODO: create_trade helper
|
|
# account, strategy, base, quote, direction
|
|
# pull all data to create the trade from the strategy
|
|
# complete all crossfilter and risk management checks, etc.
|
|
|
|
|
|
def execute_strategy(callback, strategy, func):
|
|
"""
|
|
Execute a strategy.
|
|
:param callback: Callback object
|
|
:param strategy: Strategy object
|
|
"""
|
|
|
|
# Only check times for entries. We can always exit trades and set trends.
|
|
if func == "entry":
|
|
# Check if we can trade now!
|
|
now_utc = datetime.utcnow()
|
|
trading_times = strategy.trading_times.all()
|
|
if not trading_times:
|
|
log.error("No trading times set for strategy")
|
|
return
|
|
matches = [x.within_range(now_utc) for x in trading_times]
|
|
if not any(matches):
|
|
log.debug("Not within trading time range")
|
|
return
|
|
|
|
# Don't touch the account if it's disabled.
|
|
# We still want to set trends, though.
|
|
if func in ("entry", "exit"):
|
|
if not strategy.account.enabled:
|
|
log.debug("Account is disabled, exiting")
|
|
return
|
|
|
|
# Instruments supported by the account
|
|
if not strategy.account.instruments:
|
|
strategy.account.update_info()
|
|
# Refresh account object
|
|
strategy.account = Account.objects.get(id=strategy.account.id)
|
|
|
|
# Shorten some hook, strategy and callback vars for convenience
|
|
user = strategy.user
|
|
account = strategy.account
|
|
hook = callback.hook
|
|
signal = callback.signal
|
|
base = callback.base
|
|
quote = callback.quote
|
|
direction = signal.direction
|
|
|
|
# Don't be silly
|
|
if callback.exchange != account.exchange:
|
|
log.error("Market exchange differs from account exchange.")
|
|
sendmsg(user, "Market exchange differs from account exchange.", title="Error")
|
|
return
|
|
|
|
# Get the pair we are trading
|
|
symbol = common.get_pair(account, base, quote)
|
|
if not symbol:
|
|
sendmsg(user, f"Symbol not supported by account: {symbol}", title="Error")
|
|
log.error(f"Symbol not supported by account: {symbol}")
|
|
return
|
|
|
|
# Get the precision for the symbol
|
|
trade_precision, display_precision = get_precision(account, symbol)
|
|
if trade_precision is None or display_precision is None:
|
|
# sendmsg(user, f"Precision not found for {symbol}", title="Error")
|
|
log.error(f"Market precision not found for {symbol} from {account}")
|
|
return
|
|
|
|
# Round the received price to the display precision
|
|
price = round(D(callback.price), display_precision)
|
|
log.debug(f"Extracted price of quote: {price}")
|
|
|
|
current_price = get_price(account, direction, symbol)
|
|
log.debug(f"Callback price: {price}")
|
|
log.debug(f"Current price: {current_price}")
|
|
|
|
# Calculate price bound and round to the display precision
|
|
price_bound = get_price_bound(direction, strategy, price, current_price)
|
|
if not price_bound:
|
|
return
|
|
price_bound = round(price_bound, display_precision)
|
|
|
|
# Callback now verified
|
|
|
|
# Check against the asset groups
|
|
if func == "entry" and strategy.asset_group is not None:
|
|
allowed = assetfilter.get_allowed(strategy.asset_group, base, quote, direction)
|
|
log.debug(f"Asset filter allowed for {strategy.asset_group}: {allowed}")
|
|
if not allowed:
|
|
log.debug(
|
|
f"Denied trading {symbol} due to asset filter {strategy.asset_group}"
|
|
)
|
|
sendmsg(
|
|
user,
|
|
f"Denied trading {symbol} due to asset filter {strategy.asset_group}",
|
|
title="Asset filter denied",
|
|
)
|
|
return
|
|
|
|
if func == "exit":
|
|
check_exit = crossfilter(account, symbol, direction, func)
|
|
if check_exit is None:
|
|
return
|
|
if not check_exit:
|
|
log.debug("Exit conditions not met.")
|
|
return
|
|
if check_exit["action"] == "close":
|
|
log.debug(f"Closing position on exit signal: {symbol}")
|
|
side = check_exit["side"]
|
|
response = account.client.close_position(side, symbol)
|
|
log.debug(f"Close position response: {response}")
|
|
sendmsg(
|
|
user,
|
|
f"Closing {side} position on exit signal: {symbol}",
|
|
title="Exit signal",
|
|
)
|
|
return
|
|
|
|
# Set the trend
|
|
elif func == "trend":
|
|
if strategy.trends is None:
|
|
strategy.trends = {}
|
|
strategy.trends[symbol] = direction
|
|
strategy.save()
|
|
log.debug(f"Set trend for {symbol}: {direction}")
|
|
return
|
|
|
|
# Check if we are trading against the trend
|
|
if strategy.trend_signals.exists():
|
|
if strategy.trends is None:
|
|
log.debug("Refusing to trade with no trend signals received")
|
|
sendmsg(
|
|
user,
|
|
f"Refusing to trade {symbol} with no trend signals received",
|
|
title="Trend not ready",
|
|
)
|
|
return
|
|
if symbol not in strategy.trends:
|
|
log.debug("Refusing to trade asset without established trend")
|
|
sendmsg(
|
|
user,
|
|
f"Refusing to trade {symbol} without established trend",
|
|
title="Trend not ready",
|
|
)
|
|
return
|
|
else:
|
|
if strategy.trends[symbol] != direction:
|
|
log.debug("Refusing to trade against the trend")
|
|
sendmsg(
|
|
user,
|
|
f"Refusing to trade {symbol} against the trend",
|
|
title="Trend rejection",
|
|
)
|
|
return
|
|
else:
|
|
log.debug(f"Trend check passed for {symbol} - {direction}")
|
|
|
|
type = strategy.order_settings.order_type
|
|
|
|
# Get the account's balance in the native account currency
|
|
cash_balance = strategy.account.client.get_balance()
|
|
log.debug(f"Cash balance: {cash_balance}")
|
|
|
|
# Convert the trade size, which is currently in the account's base currency,
|
|
# to the base currency of the pair we are trading
|
|
trade_size_in_base = get_trade_size_in_base(
|
|
direction, account, strategy, cash_balance, base
|
|
)
|
|
|
|
# Calculate TP/SL/TSL
|
|
protection = get_tp_sl(
|
|
direction, strategy, current_price, round_to=display_precision
|
|
)
|
|
# protection_cast = {}
|
|
# if "sl" in protection:
|
|
# protection_cast["stop_loss"] = float(round(protect
|
|
# ion["sl"], display_precision))
|
|
# if "tp" in protection:
|
|
# protection_cast["take_profit"] = float(
|
|
# round(protection["tp"], display_precision)
|
|
# )
|
|
# if "tsl" in protection:
|
|
# protection_cast["trailing_stop_loss"] = float(
|
|
# round(protection["tsl"], display_precision)
|
|
# )
|
|
|
|
# Create object, note that the amount is rounded to the trade precision
|
|
amount_rounded = float(round(trade_size_in_base, trade_precision))
|
|
new_trade = Trade.objects.create(
|
|
user=user,
|
|
account=account,
|
|
hook=hook,
|
|
signal=signal,
|
|
symbol=symbol,
|
|
type=type,
|
|
time_in_force=strategy.order_settings.time_in_force,
|
|
# amount_fiat=amount_fiat,
|
|
amount=amount_rounded,
|
|
# price=price_bound,
|
|
price=price_bound,
|
|
direction=direction,
|
|
**protection,
|
|
)
|
|
new_trade.save()
|
|
|
|
if strategy.risk_model is not None:
|
|
allowed = check_risk(strategy.risk_model, account, new_trade)
|
|
if not allowed["allowed"]:
|
|
new_trade.status = "rejected"
|
|
new_trade.information = allowed["reason"]
|
|
new_trade.save()
|
|
sendmsg(
|
|
user,
|
|
f"Trade rejected due to risk model: {allowed['reason']}",
|
|
title="Trade rejected",
|
|
)
|
|
return
|
|
|
|
# Run the crossfilter to ensure we don't trade the same pair in opposite directions
|
|
filtered = crossfilter(account, symbol, direction, func)
|
|
|
|
# TP/SL calculation and get_trade_size_in_base are wasted here, but it's important
|
|
# to record the decision in the Trade object. We can only get it after we do those.
|
|
# It shows what would be done.
|
|
if filtered:
|
|
log.debug(f"Trade filtered. Action: {filtered['action']}")
|
|
if filtered["action"] == "rejected":
|
|
new_trade.status = "rejected"
|
|
new_trade.save()
|
|
sendmsg(
|
|
user,
|
|
(
|
|
f"{direction} on {symbol} rejected due to conflicting position: "
|
|
f"{filtered['positions']}"
|
|
),
|
|
title="Trade rejected",
|
|
)
|
|
else:
|
|
info = new_trade.post()
|
|
log.debug(f"Posted trade: {info}")
|
|
|
|
# Send notification with limited number of fields
|
|
wanted_fields = ["requestID", "type", "symbol", "units", "reason"]
|
|
sendmsg(
|
|
user,
|
|
", ".join([str(v) for k, v in info.items() if k in wanted_fields]),
|
|
title=f"{direction} {amount_rounded} on {symbol}",
|
|
)
|
|
|
|
|
|
def process_callback(callback):
|
|
log.info(f"Received callback for {callback.hook} - {callback.signal}")
|
|
|
|
# Scan for trend
|
|
log.debug("Scanning for trend strategies...")
|
|
strategies = Strategy.objects.filter(
|
|
trend_signals=callback.signal, signal_trading_enabled=True, enabled=True
|
|
)
|
|
log.debug(f"Matched strategies: {strategies}")
|
|
for strategy in strategies:
|
|
log.debug(f"Executing strategy {strategy}")
|
|
if callback.hook.user != strategy.user:
|
|
log.error("Ownership differs between callback and strategy.")
|
|
continue
|
|
execute_strategy(callback, strategy, func="trend")
|
|
|
|
# Scan for entry
|
|
log.debug("Scanning for entry strategies...")
|
|
strategies = Strategy.objects.filter(
|
|
entry_signals=callback.signal, signal_trading_enabled=True, enabled=True
|
|
)
|
|
log.debug(f"Matched strategies: {strategies}")
|
|
for strategy in strategies:
|
|
log.debug(f"Executing strategy {strategy}")
|
|
if callback.hook.user != strategy.user:
|
|
log.error("Ownership differs between callback and strategy.")
|
|
continue
|
|
execute_strategy(callback, strategy, func="entry")
|
|
|
|
# Scan for exit
|
|
log.debug("Scanning for exit strategies...")
|
|
strategies = Strategy.objects.filter(
|
|
exit_signals=callback.signal, signal_trading_enabled=True, enabled=True
|
|
)
|
|
log.debug(f"Matched strategies: {strategies}")
|
|
for strategy in strategies:
|
|
log.debug(f"Executing strategy {strategy}")
|
|
if callback.hook.user != strategy.user:
|
|
log.error("Ownership differs between callback and strategy.")
|
|
continue
|
|
execute_strategy(callback, strategy, func="exit")
|