def _init_objects(self):
"""
This method gets called after right creating the Strategy object. It
is just a workaround as a part of not being able to set them inside
self.__init__() for the purpose of removing __init__() methods from strategies.
"""
self.position = selectors.get_position(self.exchange, self.symbol)
self.broker = Broker(self.position, self.exchange, self.symbol, self.timeframe)
def _init_objects(self) -> None:
"""
This method gets called after right creating the Strategy object. It
is just a workaround as a part of not being able to set them inside
self.__init__() for the purpose of removing __init__() methods from strategies.
"""
self.position = selectors.get_position(self.exchange, self.symbol)
self.broker = Broker(self.position, self.exchange, self.symbol, self.timeframe)
if self.hp is None and len(self.hyperparameters()) > 0:
self.hp = {}
for dna in self.hyperparameters():
self.hp[dna['name']] = dna['default']
def set_up_with_fee(is_margin_trading=False):
reset_config()
config['env']['exchanges'][exchanges.SANDBOX]['fee'] = 0.002
config['env']['exchanges'][exchanges.SANDBOX]['assets'] = [
{
'asset': 'USDT',
'balance': 1000
},
{
'asset': 'BTC',
'balance': 0
},
]
if is_margin_trading:
# used only in margin trading
config['env']['exchanges'][exchanges.SANDBOX]['type'] = 'margin'
else:
config['env']['exchanges'][exchanges.SANDBOX]['type'] = 'spot'
config['env']['exchanges'][
exchanges.SANDBOX]['settlement_currency'] = 'USDT'
config['app']['trading_mode'] = 'backtest'
config['app']['considering_exchanges'] = ['Sandbox']
router.set_routes([(exchanges.SANDBOX, 'BTC-USDT', '5m', 'Test19')])
store.reset(True)
global position
global exchange
global broker
position = selectors.get_position(exchanges.SANDBOX, 'BTC-USDT')
position.current_price = 50
exchange = selectors.get_exchange(exchanges.SANDBOX)
broker = Broker(position, exchanges.SANDBOX, 'BTC-USDT',
timeframes.MINUTE_5)
def set_up_with_fee():
reset_config()
config['env']['exchanges'][exchanges.SANDBOX]['fee'] = 0.002
config['env']['exchanges'][exchanges.SANDBOX]['starting_balance'] = 1000
config['app']['trading_mode'] = 'backtest'
config['app']['considering_exchanges'] = ['Sandbox']
router.set_routes([(exchanges.SANDBOX, 'BTCUSD', '5m', 'Test19')])
store.reset(True)
global position
global exchange
global broker
position = selectors.get_position(exchanges.SANDBOX, 'BTCUSD')
position.current_price = 50
exchange = selectors.get_exchange(exchanges.SANDBOX)
broker = Broker(position, exchanges.SANDBOX, 'BTCUSD', timeframes.MINUTE_5)
def set_up_with_fee(is_futures_trading=False):
reset_config()
config['env']['exchanges'][exchanges.SANDBOX]['fee'] = 0.002
config['env']['exchanges'][exchanges.SANDBOX]['assets'] = [
{
'asset': 'USDT',
'balance': 1000
},
{
'asset': 'BTC',
'balance': 0
},
]
if is_futures_trading:
# used only in futures trading
config['env']['exchanges'][exchanges.SANDBOX]['type'] = 'futures'
else:
config['env']['exchanges'][exchanges.SANDBOX]['type'] = 'spot'
config['env']['exchanges'][
exchanges.SANDBOX]['settlement_currency'] = 'USDT'
config['app']['trading_mode'] = 'backtest'
config['app']['considering_exchanges'] = ['Sandbox']
router.initiate([{
'exchange': exchanges.SANDBOX,
'symbol': 'BTC-USDT',
'timeframe': '5m',
'strategy': 'Test19'
}], [])
global position
global exchange
global broker
position = selectors.get_position(exchanges.SANDBOX, 'BTC-USDT')
position.current_price = 50
exchange = selectors.get_exchange(exchanges.SANDBOX)
broker = Broker(position, exchanges.SANDBOX, 'BTC-USDT',
timeframes.MINUTE_5)
class Strategy(ABC):
"""The parent strategy class which every strategy must extend"""
def __init__(self) -> None:
self.id = jh.generate_unique_id()
self.name = None
self.symbol = None
self.exchange = None
self.timeframe = None
self.hp = None
self.index = 0
self.vars = {}
self.increased_count = 0
self.reduced_count = 0
self.buy = None
self._buy = None
self.sell = None
self._sell = None
self.stop_loss = None
self._stop_loss = None
self.take_profit = None
self._take_profit = None
self._log_take_profit = None
self._log_stop_loss = None
self._open_position_orders = []
self._stop_loss_orders = []
self._take_profit_orders = []
self.trade: CompletedTrade = None
self.trades_count = 0
self._is_executing = False
self._is_initiated = False
self.position: Position = None
self.broker = None
self._cached_metrics = {}
def _init_objects(self) -> None:
"""
This method gets called after right creating the Strategy object. It
is just a workaround as a part of not being able to set them inside
self.__init__() for the purpose of removing __init__() methods from strategies.
"""
self.position = selectors.get_position(self.exchange, self.symbol)
self.broker = Broker(self.position, self.exchange, self.symbol,
self.timeframe)
if self.hp is None:
if len(self.hyperparameters()) > 0:
self.hp = {}
for dna in self.hyperparameters():
self.hp[dna['name']] = dna['default']
def _broadcast(self, msg: str) -> None:
"""Broadcasts the event to all OTHER strategies
Arguments:
msg {str} -- [the message to broadcast]
"""
from jesse.routes import router
for r in router.routes:
# skip self
if r.strategy.id == self.id:
continue
if msg == 'route-open-position':
r.strategy.on_route_open_position(self)
elif msg == 'route-stop-loss':
r.strategy.on_route_stop_loss(self)
elif msg == 'route-take-profit':
r.strategy.on_route_take_profit(self)
elif msg == 'route-increased-position':
r.strategy.on_route_increased_position(self)
elif msg == 'route-reduced-position':
r.strategy.on_route_reduced_position(self)
elif msg == 'route-canceled':
r.strategy.on_route_canceled(self)
r.strategy._detect_and_handle_entry_and_exit_modifications()
def _on_updated_position(self, order: Order) -> None:
"""
Handles the after-effect of the executed order
Note that it assumes that the position has already been affected
by the executed order.
Arguments:
order {Order} -- the executed order object
"""
role = order.role
if role == order_roles.OPEN_POSITION and abs(self.position.qty) != abs(
order.qty):
order.role = order_roles.INCREASE_POSITION
role = order_roles.INCREASE_POSITION
if role == order_roles.CLOSE_POSITION and self.position.is_open:
order.role = order_roles.REDUCE_POSITION
role = order_roles.REDUCE_POSITION
self._log_position_update(order, role)
if role == order_roles.OPEN_POSITION:
self._on_open_position(order)
elif role == order_roles.CLOSE_POSITION and order in self._take_profit_orders:
self._on_take_profit(order)
elif role == order_roles.CLOSE_POSITION and order in self._stop_loss_orders:
self._on_stop_loss(order)
elif role == order_roles.INCREASE_POSITION:
self._on_increased_position(order)
elif role == order_roles.REDUCE_POSITION:
self._on_reduced_position(order)
def filters(self) -> list:
return []
def hyperparameters(self) -> list:
return []
def _execute_long(self) -> None:
self.go_long()
# validation
if self.buy is None:
raise exceptions.InvalidStrategy(
'You forgot to set self.buy. example [qty, price]')
elif type(self.buy) not in [tuple, list]:
raise exceptions.InvalidStrategy(
'self.buy must be either a list or a tuple. example: [qty, price]'
)
self._prepare_buy()
if self.take_profit is not None:
# validate
self._validate_take_profit()
self._prepare_take_profit()
if self.stop_loss is not None:
# validate
self._validate_stop_loss()
self._prepare_stop_loss()
# filters
passed = self._execute_filters()
if not passed:
return
for o in self._buy:
# STOP order
if o[1] > self.price:
self._open_position_orders.append(
self.broker.start_profit_at(sides.BUY, o[0], o[1],
order_roles.OPEN_POSITION))
# LIMIT order
elif o[1] < self.price:
self._open_position_orders.append(
self.broker.buy_at(o[0], o[1], order_roles.OPEN_POSITION))
# MARKET order
elif o[1] == self.price:
self._open_position_orders.append(
self.broker.buy_at_market(o[0], order_roles.OPEN_POSITION))
def _prepare_buy(self, make_copies: bool = True) -> None:
if type(self.buy) is np.ndarray:
return
# create a copy in the placeholders variables so we can detect future modifications
# also, make it list of orders even if there's only one, to make it easier to loop
if type(self.buy[0]) not in [list, tuple]:
self.buy = [self.buy]
self.buy = self._convert_to_numpy_array(self.buy, 'self.buy')
if make_copies:
self._buy = self.buy.copy()
def _prepare_sell(self, make_copies: bool = True) -> None:
if type(self.sell) is np.ndarray:
return
# create a copy in the placeholders variables so we can detect future modifications
# also, make it list of orders even if there's only one, to make it easier to loop
if type(self.sell[0]) not in [list, tuple]:
self.sell = [self.sell]
self.sell = self._convert_to_numpy_array(self.sell, 'self.sell')
if make_copies:
self._sell = self.sell.copy()
def _prepare_stop_loss(self, make_copies: bool = True) -> None:
# if it's numpy, then it has already been prepared
if type(self.stop_loss) is np.ndarray:
return
if type(self.stop_loss[0]) not in [list, tuple, np.ndarray]:
self.stop_loss = [self.stop_loss]
self.stop_loss = self._convert_to_numpy_array(self.stop_loss,
'self.stop_loss')
if make_copies:
self._stop_loss = self.stop_loss.copy()
self._log_stop_loss = self._stop_loss.copy()
def _prepare_take_profit(self, make_copies: bool = True) -> None:
# if it's numpy, then it has already been prepared
if type(self.take_profit) is np.ndarray:
return
if type(self.take_profit[0]) not in [list, tuple, np.ndarray]:
self.take_profit = [self.take_profit]
self.take_profit = self._convert_to_numpy_array(
self.take_profit, 'self.take_profit')
if make_copies:
self._take_profit = self.take_profit.copy()
self._log_take_profit = self._take_profit.copy()
@staticmethod
def _convert_to_numpy_array(arr, name) -> np.ndarray:
if type(arr) is np.ndarray:
return arr
try:
# create numpy array from list
arr = np.array(arr, dtype=float)
if jh.is_live():
# in livetrade mode, we'll need them rounded
price = arr[0][1]
prices = jh.round_price_for_live_mode(price, arr[:, 1])
qtys = jh.round_qty_for_live_mode(price, arr[:, 0])
arr[:, 0] = qtys
arr[:, 1] = prices
return arr
except ValueError:
raise exceptions.InvalidShape(
'The format of {} is invalid. \n'
'It must be (qty, price) or [(qty, price), (qty, price)] for multiple points; but {} was given'
.format(name, arr))
def _validate_stop_loss(self) -> None:
if self.stop_loss is None:
raise exceptions.InvalidStrategy(
'You forgot to set self.stop_loss. example [qty, price]')
elif type(self.stop_loss) not in [tuple, list, np.ndarray]:
raise exceptions.InvalidStrategy(
'self.stop_loss must be either a list or a tuple. example: [qty, price]'
)
def _validate_take_profit(self) -> None:
if self.take_profit is None:
raise exceptions.InvalidStrategy(
'You forgot to set self.take_profit. example [qty, price]')
elif type(self.take_profit) not in [tuple, list, np.ndarray]:
raise exceptions.InvalidStrategy(
'self.take_profit must be either a list or a tuple. example: [qty, price]'
)
def _execute_short(self) -> None:
self.go_short()
# validation
if self.sell is None:
raise exceptions.InvalidStrategy(
'You forgot to set self.sell. example [qty, price]')
elif type(self.sell) not in [tuple, list]:
raise exceptions.InvalidStrategy(
'self.sell must be either a list or a tuple. example: [qty, price]'
)
self._prepare_sell()
if self.take_profit is not None:
self._validate_take_profit()
self._prepare_take_profit()
if self.stop_loss is not None:
self._validate_stop_loss()
self._prepare_stop_loss()
# filters
passed = self._execute_filters()
if not passed:
return
for o in self._sell:
# STOP order
if o[1] < self.price:
self._open_position_orders.append(
self.broker.start_profit_at(sides.SELL, o[0], o[1],
order_roles.OPEN_POSITION))
# LIMIT order
elif o[1] > self.price:
self._open_position_orders.append(
self.broker.sell_at(o[0], o[1], order_roles.OPEN_POSITION))
# MARKET order
elif o[1] == self.price:
self._open_position_orders.append(
self.broker.sell_at_market(o[0],
order_roles.OPEN_POSITION))
def _execute_filters(self) -> bool:
for f in self.filters():
try:
passed = f()
except TypeError:
raise exceptions.InvalidStrategy(
"Invalid filter format. You need to pass filter methods WITHOUT calling them "
"(no parentheses must be present at the end)"
"\n\n"
u"\u274C " + "Incorrect Example:\n"
"return [\n"
" self.filter_1()\n"
"]\n\n"
u"\u2705 " + "Correct Example:\n"
"return [\n"
" self.filter_1\n"
"]\n")
if passed == False:
logger.info(f.__name__)
self._reset()
return False
return True
@abstractmethod
def go_long(self):
pass
@abstractmethod
def go_short(self):
pass
def _execute_cancel(self) -> None:
"""
cancels everything so that the strategy can keep looking for new trades.
"""
# validation
if self.position.is_open:
raise Exception(
'cannot cancel orders when position is still open. there must be a bug somewhere.'
)
logger.info(
'cancel all remaining orders to prepare for a fresh start...')
self.broker.cancel_all_orders()
self._reset()
self._broadcast('route-canceled')
self.on_cancel()
if not jh.is_unit_testing() and not jh.is_live():
store.orders.storage['{}-{}'.format(self.exchange,
self.symbol)].clear()
def _reset(self) -> None:
self.buy = None
self._buy = None
self.sell = None
self._sell = None
self.stop_loss = None
self._stop_loss = None
self.take_profit = None
self._take_profit = None
self._log_take_profit = None
self._log_stop_loss = None
self._open_position_orders = []
self._stop_loss_orders = []
self._take_profit_orders = []
self.increased_count = 0
self.reduced_count = 0
def on_cancel(self):
"""
what should happen after all active orders have been cancelled
"""
pass
@abstractmethod
def should_long(self) -> bool:
"""are all filters good to execute buy"""
pass
@abstractmethod
def should_short(self) -> bool:
"""are all filters good to execute sell"""
pass
@abstractmethod
def should_cancel(self) -> bool:
pass
def before(self):
"""
Get's executed BEFORE executing the strategy's logic
"""
pass
def after(self):
"""
Get's executed AFTER executing the strategy's logic
"""
pass
def _update_position(self) -> None:
self.update_position()
self._detect_and_handle_entry_and_exit_modifications()
def _detect_and_handle_entry_and_exit_modifications(self) -> None:
if self.position.is_close:
return
try:
if self.is_long:
# prepare format
self._prepare_buy(make_copies=False)
# if entry has been modified
if not np.array_equal(self.buy, self._buy):
self._buy = self.buy.copy()
# cancel orders
for o in self._open_position_orders:
if o.is_active or o.is_queued:
self.broker.cancel_order(o.id)
# clean orders array but leave executed ones
self._open_position_orders = [
o for o in self._open_position_orders if o.is_executed
]
for o in self._buy:
# STOP order
if o[1] > self.price:
self._open_position_orders.append(
self.broker.start_profit_at(
sides.BUY, o[0], o[1],
order_roles.OPEN_POSITION))
# LIMIT order
elif o[1] < self.price:
self._open_position_orders.append(
self.broker.buy_at(o[0], o[1],
order_roles.OPEN_POSITION))
# MARKET order
elif o[1] == self.price:
self._open_position_orders.append(
self.broker.buy_at_market(
o[0], order_roles.OPEN_POSITION))
elif self.is_short:
# prepare format
self._prepare_sell(make_copies=False)
# if entry has been modified
if not np.array_equal(self.sell, self._sell):
self._sell = self.sell.copy()
# cancel orders
for o in self._open_position_orders:
if o.is_active or o.is_queued:
self.broker.cancel_order(o.id)
# clean orders array but leave executed ones
self._open_position_orders = [
o for o in self._open_position_orders if o.is_executed
]
for o in self._sell:
# STOP order
if o[1] < self.price:
self._open_position_orders.append(
self.broker.start_profit_at(
sides.SELL, o[0], o[1],
order_roles.OPEN_POSITION))
# LIMIT order
elif o[1] > self.price:
self._open_position_orders.append(
self.broker.sell_at(o[0], o[1],
order_roles.OPEN_POSITION))
# MARKET order
elif o[1] == self.price:
self._open_position_orders.append(
self.broker.sell_at_market(
o[0], order_roles.OPEN_POSITION))
if self.position.is_open and self.take_profit is not None:
self._validate_take_profit()
self._prepare_take_profit(False)
# if _take_profit has been modified
if not np.array_equal(self.take_profit, self._take_profit):
self._take_profit = self.take_profit.copy()
# cancel orders
for o in self._take_profit_orders:
if o.is_active or o.is_queued:
self.broker.cancel_order(o.id)
# clean orders array but leave executed ones
self._take_profit_orders = [
o for o in self._take_profit_orders if o.is_executed
]
self._log_take_profit = []
for s in self._take_profit_orders:
self._log_take_profit.append((abs(s.qty), s.price))
for o in self._take_profit:
self._log_take_profit.append(o)
self._take_profit_orders.append(
self.broker.reduce_position_at(
o[0], o[1], order_roles.CLOSE_POSITION))
if self.position.is_open and self.stop_loss is not None:
self._validate_stop_loss()
self._prepare_stop_loss(False)
# if stop_loss has been modified
if not np.array_equal(self.stop_loss, self._stop_loss):
# prepare format
self._stop_loss = self.stop_loss.copy()
# cancel orders
for o in self._stop_loss_orders:
if o.is_active or o.is_queued:
self.broker.cancel_order(o.id)
# clean orders array but leave executed ones
self._stop_loss_orders = [
o for o in self._stop_loss_orders if o.is_executed
]
self._log_stop_loss = []
for s in self._stop_loss_orders:
self._log_stop_loss.append((abs(s.qty), s.price))
for o in self._stop_loss:
self._log_stop_loss.append(o)
self._stop_loss_orders.append(
self.broker.reduce_position_at(
o[0], o[1], order_roles.CLOSE_POSITION))
except TypeError:
raise exceptions.InvalidStrategy(
'Something odd is going on with your strategy. '
'Try running it with "--debug" to see what was going on near the end, and fix it.'
)
except:
raise
# validations: stop-loss and take-profit should not be the same
if self.position.is_open:
if (self.stop_loss is not None
and self.take_profit is not None) and np.array_equal(
self.stop_loss, self.take_profit):
raise exceptions.InvalidStrategy(
'stop-loss and take-profit should not be exactly the same. Just use either one of them and it will do.'
)
def update_position(self):
pass
def _check(self) -> None:
"""Based on the newly updated info, check if we should take action or not"""
if not self._is_initiated:
self._is_initiated = True
if jh.is_live() and jh.is_debugging():
logger.info('Executing {}-{}-{}-{}'.format(
self.name, self.exchange, self.symbol, self.timeframe))
# for caution to make sure testing on livetrade won't bleed your account
if jh.is_test_driving() and store.completed_trades.count >= 2:
logger.info('Maximum allowed trades in test-drive mode is reached')
return
if self._open_position_orders != [] and self.is_close and self.should_cancel(
):
self._execute_cancel()
# make sure order cancellation response is received via WS
if jh.is_live():
# sleep a little until cancel is received via WS
sleep(0.1)
# just in case, sleep some more if necessary
for _ in range(20):
if store.orders.count_active_orders(
self.exchange, self.symbol) == 0:
break
logger.info('sleeping 0.2 more seconds...')
sleep(0.2)
# If it's still not cancelled, something is wrong. Handle cancellation failure
if store.orders.count_active_orders(self.exchange,
self.symbol) != 0:
raise exceptions.ExchangeNotResponding(
'The exchange did not respond as expected')
if self.position.is_open:
self._update_position()
if jh.is_backtesting() or jh.is_unit_testing():
store.orders.execute_pending_market_orders()
if self.position.is_close and self._open_position_orders == []:
should_short = self.should_short()
should_long = self.should_long()
# validation
if should_short and should_long:
raise exceptions.ConflictingRules(
'should_short and should_long should not be true at the same time.'
)
if should_long:
self._execute_long()
elif should_short:
self._execute_short()
def _on_open_position(self, order: Order) -> None:
self.increased_count = 1
self._broadcast('route-open-position')
if self.take_profit is not None:
for o in self._take_profit:
# validation: make sure take-profit will exit with profit
if self.is_long:
if o[1] <= self.position.entry_price:
raise exceptions.InvalidStrategy(
'take-profit({}) must be above entry-price({}) in a long position'
.format(o[1], self.position.entry_price))
elif self.is_short:
if o[1] >= self.position.entry_price:
raise exceptions.InvalidStrategy(
'take-profit({}) must be below entry-price({}) in a short position'
.format(o[1], self.position.entry_price))
# submit take-profit
self._take_profit_orders.append(
self.broker.reduce_position_at(o[0], o[1],
order_roles.CLOSE_POSITION))
if self.stop_loss is not None:
for o in self._stop_loss:
# validation
if self.is_long:
if o[1] >= self.position.entry_price:
raise exceptions.InvalidStrategy(
'stop-loss({}) must be below entry-price({}) in a long position'
.format(o[1], self.position.entry_price))
elif self.is_short:
if o[1] <= self.position.entry_price:
raise exceptions.InvalidStrategy(
'stop-loss({}) must be above entry-price({}) in a short position'
.format(o[1], self.position.entry_price))
# submit stop-loss
self._stop_loss_orders.append(
self.broker.stop_loss_at(o[0], o[1],
order_roles.CLOSE_POSITION))
self._open_position_orders = []
self.on_open_position(order)
self._detect_and_handle_entry_and_exit_modifications()
def on_open_position(self, order: Order):
"""
What should happen after the open position order has been executed
"""
pass
def _on_stop_loss(self, order: Order) -> None:
if not jh.should_execute_silently() or jh.is_debugging():
logger.info('Stop-loss has been executed.')
self._broadcast('route-stop-loss')
self._execute_cancel()
self.on_stop_loss(order)
self._detect_and_handle_entry_and_exit_modifications()
def on_stop_loss(self, order: Order):
"""
What should happen after the stop-loss order has been executed
"""
pass
def _on_take_profit(self, order: Order) -> None:
if not jh.should_execute_silently() or jh.is_debugging():
logger.info("Take-profit order has been executed.")
self._broadcast('route-take-profit')
self._execute_cancel()
self.on_take_profit(order)
self._detect_and_handle_entry_and_exit_modifications()
def on_take_profit(self, order: Order):
"""
What should happen after the take-profit order is executed.
"""
pass
def _on_increased_position(self, order: Order) -> None:
self.increased_count += 1
self._open_position_orders = []
self._broadcast('route-increased-position')
self.on_increased_position(order)
self._detect_and_handle_entry_and_exit_modifications()
def on_increased_position(self, order: Order):
"""
What should happen after the order (if any) increasing the
size of the position is executed. Overwrite it if needed.
And leave it be if your strategy doesn't require it
"""
pass
def _on_reduced_position(self, order: Order) -> None:
"""
prepares for on_reduced_position() is implemented by user
"""
self.reduced_count += 1
self._open_position_orders = []
self._broadcast('route-reduced-position')
self.on_reduced_position(order)
self._detect_and_handle_entry_and_exit_modifications()
def on_reduced_position(self, order: Order):
"""
What should happen after the order (if any) reducing the size of the position is executed.
"""
pass
def on_route_open_position(self, strategy):
"""used when trading multiple routes that related
Arguments:
strategy {Strategy} -- the strategy that has fired (and not listening to) the event
"""
pass
def on_route_stop_loss(self, strategy):
"""used when trading multiple routes that related
"""
pass
def on_route_take_profit(self, strategy):
"""used when trading multiple routes that related
Arguments:
strategy {Strategy} -- the strategy that has fired (and not listening to) the event
"""
pass
def on_route_increased_position(self, strategy):
"""used when trading multiple routes that related
Arguments:
strategy {Strategy} -- the strategy that has fired (and not listening to) the event
"""
pass
def on_route_reduced_position(self, strategy):
"""used when trading multiple routes that related
Arguments:
strategy {Strategy} -- the strategy that has fired (and not listening to) the event
"""
pass
def on_route_canceled(self, strategy):
"""used when trading multiple routes that related
Arguments:
strategy {Strategy} -- the strategy that has fired (and not listening to) the event
"""
pass
def _execute(self) -> None:
"""
Handles the execution permission for the strategy.
"""
# make sure we don't execute this strategy more than once at the same time.
if self._is_executing is True:
return
self._is_executing = True
self.before()
self._check()
self.after()
self._is_executing = False
self.index += 1
def _terminate(self) -> None:
"""
Optional for executing code after completion of a backTest.
This block will not execute in live use as a live
Jesse is never ending.
"""
if not jh.should_execute_silently() or jh.is_debugging():
logger.info("Terminating strategy...")
self.terminate()
self._detect_and_handle_entry_and_exit_modifications()
# fake execution of market orders in backtest simulation
if not jh.is_live():
store.orders.execute_pending_market_orders()
if jh.is_live():
return
if self.position.is_open:
store.app.total_open_trades += 1
store.app.total_open_pl += self.position.pnl
logger.info(
"Closed open {}-{} position at {} with PNL: {}({}%) because we reached the end of the backtest session."
.format(self.exchange,
self.symbol, self.position.current_price,
round(self.position.pnl, 4),
round(self.position.pnl_percentage, 2)))
# fake a closing (market) order so that the calculations would be correct
self.broker.reduce_position_at(self.position.qty,
self.position.current_price,
order_roles.CLOSE_POSITION)
return
if self._open_position_orders:
self._execute_cancel()
logger.info(
'Canceled open-position orders because we reached the end of the backtest session.'
)
def terminate(self):
pass
def watch_list(self) -> list:
"""
returns an array containing an array of key-value items that should
be logged when backTested, and monitored while liveTraded
Returns:
[array[{"key": v, "value": v}]] -- an array of dictionary objects
"""
return []
@property
def current_candle(self) -> np.ndarray:
"""
Returns current trading candle
:return: np.ndarray
"""
return store.candles.get_current_candle(self.exchange, self.symbol,
self.timeframe).copy()
@property
def open(self) -> float:
"""
Returns the closing price of the current candle for this strategy.
Just as a helper to use when writing super simple strategies.
Returns:
[float] -- the current trading candle's OPEN price
"""
return self.current_candle[1]
@property
def close(self) -> float:
"""
Returns the closing price of the current candle for this strategy.
Just as a helper to use when writing super simple strategies.
Returns:
[float] -- the current trading candle's CLOSE price
"""
return self.current_candle[2]
@property
def price(self) -> float:
"""
Same as self.close, except in livetrde, this is rounded as the exchanges require it.
Returns:
[float] -- the current trading candle's current(close) price
"""
return self.position.current_price
@property
def high(self) -> float:
"""
Returns the closing price of the current candle for this strategy.
Just as a helper to use when writing super simple strategies.
Returns:
[float] -- the current trading candle's HIGH price
"""
return self.current_candle[3]
@property
def low(self) -> float:
"""
Returns the closing price of the current candle for this strategy.
Just as a helper to use when writing super simple strategies.
Returns:
[float] -- the current trading candle's LOW price
"""
return self.current_candle[4]
@property
def candles(self) -> np.ndarray:
"""
Returns candles for current trading route
:return: np.ndarray
"""
return store.candles.get_candles(self.exchange, self.symbol,
self.timeframe)
def get_candles(self, exchange: str, symbol: str,
timeframe: str) -> np.ndarray:
"""
Get candles by passing exchange, symbol, and timeframe
:param exchange: str
:param symbol: str
:param timeframe: str
:return: np.ndarray
"""
return store.candles.get_candles(exchange, symbol, timeframe)
@property
def orders(self) -> List[Order]:
"""
Returns all the orders submitted by for this strategy. Just as a helper
to use when writing super simple strategies.
Returns:
[List[Order]] -- orders submitted by strategy
"""
return store.orders.get_orders(self.exchange, self.symbol)
@property
def trades(self) -> List[CompletedTrade]:
"""
Returns all the completed trades for this strategy.
Returns:
[List[CompletedTrade]] -- completed trades by strategy
"""
return store.completed_trades.trades
@property
def metrics(self) -> dict:
"""
Returns all the metrics of the strategy.
"""
if self.trades_count in self._cached_metrics:
return self._cached_metrics[self.trades_count]
else:
self._cached_metrics[self.trades_count] = metrics.trades(
store.completed_trades.trades, store.app.daily_balance)
return self._cached_metrics[self.trades_count]
@property
def time(self) -> int:
"""returns the current time"""
return store.app.time
@property
def balance(self) -> float:
"""alias for self.capital"""
return self.capital
@property
def capital(self) -> float:
"""the current capital in the trading exchange"""
return self.position.exchange.wallet_balance(self.symbol)
@property
def available_margin(self) -> float:
"""Current available margin considering leverage"""
return self.position.exchange.available_margin(self.symbol)
@property
def fee_rate(self) -> float:
return selectors.get_exchange(self.exchange).fee_rate
def _log_position_update(self, order: Order, role: str) -> None:
"""
A log can be either about opening, adding, reducing, or closing the position.
Arguments:
order {order} -- the order object
"""
# set the trade_id for the order if we're in the middle of a trade. Otherwise, it
# is done at order_roles.OPEN_POSITION
if self.trade:
order.trade_id = self.trade.id
if role == order_roles.OPEN_POSITION:
self.trade = CompletedTrade()
self.trade.leverage = self.leverage
self.trade.orders = [order]
self.trade.timeframe = self.timeframe
self.trade.id = jh.generate_unique_id()
order.trade_id = self.trade.id
self.trade.strategy_name = self.name
self.trade.exchange = order.exchange
self.trade.symbol = order.symbol
self.trade.type = trade_types.LONG if order.side == sides.BUY else trade_types.SHORT
self.trade.qty = order.qty
self.trade.opened_at = jh.now_to_timestamp()
self.trade.entry_candle_timestamp = self.current_candle[0]
elif role == order_roles.INCREASE_POSITION:
self.trade.orders.append(order)
self.trade.qty += order.qty
elif role == order_roles.REDUCE_POSITION:
self.trade.orders.append(order)
self.trade.qty += order.qty
elif role == order_roles.CLOSE_POSITION:
self.trade.exit_candle_timestamp = self.current_candle[0]
self.trade.orders.append(order)
# calculate average stop-loss price
sum_price = 0
sum_qty = 0
if self._log_stop_loss is not None:
for l in self._log_stop_loss:
sum_qty += abs(l[0])
sum_price += abs(l[0]) * l[1]
self.trade.stop_loss_at = sum_price / sum_qty
else:
self.trade.stop_loss_at = np.nan
# calculate average take-profit price
sum_price = 0
sum_qty = 0
if self._log_take_profit is not None:
for l in self._log_take_profit:
sum_qty += abs(l[0])
sum_price += abs(l[0]) * l[1]
self.trade.take_profit_at = sum_price / sum_qty
else:
self.trade.take_profit_at = np.nan
# calculate average entry_price price
sum_price = 0
sum_qty = 0
for l in self.trade.orders:
if not l.is_executed:
continue
if jh.side_to_type(l.side) != self.trade.type:
continue
sum_qty += abs(l.qty)
sum_price += abs(l.qty) * l.price
self.trade.entry_price = sum_price / sum_qty
# calculate average exit_price
sum_price = 0
sum_qty = 0
for l in self.trade.orders:
if not l.is_executed:
continue
if jh.side_to_type(l.side) == self.trade.type:
continue
sum_qty += abs(l.qty)
sum_price += abs(l.qty) * l.price
self.trade.exit_price = sum_price / sum_qty
self.trade.closed_at = jh.now_to_timestamp()
self.trade.qty = pydash.sum_by(
filter(lambda o: o.side == jh.type_to_side(self.trade.type),
self.trade.orders), lambda o: abs(o.qty))
store.completed_trades.add_trade(self.trade)
if jh.is_livetrading():
store_completed_trade_into_db(self.trade)
self.trade = None
self.trades_count += 1
if jh.is_livetrading():
store_order_into_db(order)
@property
def is_long(self) -> bool:
return self.position.type == 'long'
@property
def is_short(self) -> bool:
return self.position.type == 'short'
@property
def is_open(self) -> bool:
return self.position.is_open
@property
def is_close(self) -> bool:
return self.position.is_close
@property
def average_stop_loss(self) -> float:
if self._stop_loss is None:
raise exceptions.InvalidStrategy(
'You cannot access self.average_stop_loss before setting self.stop_loss'
)
arr = self._stop_loss
return (np.abs(arr[:, 0] * arr[:, 1])).sum() / np.abs(arr[:, 0]).sum()
@property
def average_take_profit(self) -> float:
if self._take_profit is None:
raise exceptions.InvalidStrategy(
'You cannot access self.average_take_profit before setting self.take_profit'
)
arr = self._take_profit
return (np.abs(arr[:, 0] * arr[:, 1])).sum() / np.abs(arr[:, 0]).sum()
@property
def average_entry_price(self) -> float:
if self.is_long:
arr = self._buy
elif self.is_short:
arr = self._sell
elif self.should_long():
arr = self._buy
elif self.should_short():
arr = self._sell
else:
return None
return (np.abs(arr[:, 0] * arr[:, 1])).sum() / np.abs(arr[:, 0]).sum()
def liquidate(self) -> None:
"""
closes open position with a MARKET order
"""
if self.position.is_close:
return
if self.position.pnl > 0:
self.take_profit = self.position.qty, self.price
else:
self.stop_loss = self.position.qty, self.price
@property
def shared_vars(self) -> dict:
return store.vars
@property
def routes(self) -> List[Route]:
from jesse.routes import router
return router.routes
@property
def has_active_entry_orders(self) -> bool:
return len(self._open_position_orders) > 0
@property
def leverage(self) -> int:
if type(self.position.exchange) is SpotExchange:
return 1
elif type(self.position.exchange) is FuturesExchange:
return self.position.exchange.futures_leverage
else:
raise ValueError('exchange type not supported!')
