def strategy(self, open, close, high, low, volume):
lot = self.exchange.get_lot()
fast_len = self.input('fast_len', int, 9)
slow_len = self.input('slow_len', int, 16)
fast_sma = sma(close, fast_len)
slow_sma = sma(close, slow_len)
golden_cross = crossover(fast_sma, slow_sma)
dead_cross = crossunder(fast_sma, slow_sma)
if golden_cross:
self.exchange.entry("Long", True, lot)
if dead_cross:
self.exchange.entry("Short", False, lot)
def strategy(self, open, close, high, low, volume):
lot = self.exchange.get_lot()
fast_len = self.input('fast_len', int, 9)
slow_len = self.input('slow_len', int, 16)
fast_sma = sma(close, fast_len)
slow_sma = sma(close, slow_len)
golden_cross = crossover(fast_sma, slow_sma)
dead_cross = crossunder(fast_sma, slow_sma)
def entry_callback(avg_price=close[-1]):
long = True if self.exchange.get_position_size() > 0 else False
logger.info(
f"{'Long' if long else 'Short'} Entry Order Successful")
if golden_cross:
self.exchange.entry("Long", True, lot, \
round_decimals=3, callback=entry_callback)
if dead_cross:
self.exchange.entry("Short", False, lot, \
round_decimals=3, callback=entry_callback)
def strategy(self, open, close, high, low, volume):
lot = self.exchange.get_lot()
# for test
# lot = int(round(lot / 100))
bitmex = BitMex(threading=False)
price = bitmex.get_market_price()
factor = self.input('factor', int, 3)
period = self.input('period', int, 7)
atrvar = atr(high, low, close, period=period)
# up = (high + low) / 2 - (factor * atr(high, low, close, period=period))
# logger.info('up:%s\n' % up)
# dn = (high + low) / 2 + (factor * atr(high, low, close, period=period))
# logger.info('atrvar: %s' % atrvar[-1])
resolution = self.input(defval=15, title="resolution",
type=int) # defval 변경, 예) 5분 --> 5
source = self.exchange.security(str(resolution) + 'm') # init 참고
supertrenddf = supertrend(source, factor, period)
# logger.info('supertrend:%s' % supertrenddf.describe())
# logger.info('supertrend:%s' % supertrenddf.columns)
logger.info('price:%s\n' % price)
# logger.info('source:%s\n' % source[-1])
logger.info('supertrend value:%s' % supertrenddf['SuperTrend'][-1])
logger.info('supertrend Upper Band:%s' %
supertrenddf['Upper Band'][-1])
logger.info('supertrend Lower Band:%s' %
supertrenddf['Lower Band'][-1])
logger.info('supertrenddf[Trend][-1]:%s' % supertrenddf['Trend'][-1])
logger.info('supertrenddf[TSL][-1]:%s' % supertrenddf['TSL'][-1])
logger.info('supertrenddf[ATR][-1]:%s' % supertrenddf['ATR'][-1])
longCondition_supertrend = crossover(
close, supertrenddf['SuperTrend']
) and close[-1] > supertrenddf['SuperTrend'][-1]
shortCondition_supertrend = crossunder(
close, supertrenddf['SuperTrend']
) and close[-1] < supertrenddf['SuperTrend'][-1]
if longCondition_supertrend:
self.exchange.entry("Long", True, lot)
logger.info('longCondition_supertrend:%s\n' %
longCondition_supertrend)
elif shortCondition_supertrend:
self.exchange.entry("Short", False, lot)
logger.info('shortCondition_supertrend:%s\n' %
shortCondition_supertrend)
else:
# self.exchange.close_all()
logger.info('Condition_supertrend:%s\n' % 'else')
self.dealcount += 1
diff = (abs(bitmex.get_balance() - abs(self.prebalance)))
realised_pnl = bitmex.get_margin()['realisedPnl']
logger.info('dealcount:%s' % self.dealcount)
logger.info('prebalance():%s' % self.prebalance)
logger.info('bitmex.get_balance():%s' % bitmex.get_balance())
logger.info('diff:%s' % diff)
logger.info('realised_pnl:%s' % realised_pnl)
# logger.info('bitmex.get_margin():%s' % bitmex.get_margin())
# logger.info('bitmex.get_position():%s' % bitmex.get_position())
# logger.info('bitmex.get_balance():%s' % bitmex.get_balance())
# logger.info('get_pre_prebalance:%s' % get_pre_prebalance(self.prebalance, bitmex.get_balance()))
# # self.exchange.close_all()
# # self.exchange.cancel_all()
logger.info('--------------------------------------------------')
def strategy(self, open, close, high, low, volume):
# get lot or set your own value which will be used to size orders
# careful default lot is about 20x your account size !!!
lot = self.exchange.get_lot()
# indicator lengths
fast_len = self.input('fast_len', int, 6)
slow_len = self.input('slow_len', int, 18)
# setting indicators, they usually take source and length as arguments
sma1 = sma(close, fast_len)
sma2 = sma(close, slow_len)
# entry conditions
long_entry_condition = crossover(sma1, sma2)
short_entry_condition = crossunder(sma1, sma2)
# setting a simple stop loss and profit target in % using built-in simple profit take and stop loss implementation
# which is placing the sl and tp automatically after entering a position
self.exchange.sltp(profit_long=1.25,
profit_short=1.25,
stop_long=1,
stop_short=1.1,
round_decimals=0)
# example of calculation of stop loss price 0.8% round on 2 decimals hardcoded inside this class
# sl_long = round(close[-1] - close[-1]*0.8/100, 2)
# sl_short = round(close[-1] - close[-1]*0.8/100, 2)
# order execution logic
if long_entry_condition:
# entry - True means long for every other order other than entry use self.exchange.order() function
self.exchange.entry("Long", True, lot / 20)
# stop loss hardcoded inside this class
#self.exchange.order("SLLong", False, lot/20, stop=sl_long, reduce_only=True, when=False)
if short_entry_condition:
# entry - False means short for every other order other than entry use self.exchange.order() function
self.exchange.entry("Short", False, lot / 20)
# stop loss hardcoded inside this class
# self.exchange.order("SLShort", True, lot/20, stop=sl_short, reduce_only=True, when=False)
# storing history for entry signals, you can store any variable this way to keep historical values
self.long_entry_signal_history.append(long_entry_condition)
self.short_entry_signal_history.append(short_entry_condition)
# OHLCV and indicator data, you can access history using list index
# log indicator values
logger.info(f"sma1: {sma1[-1]}")
logger.info(f"second last sma2: {sma2[-2]}")
# log last candle OHLCV values
logger.info(f"open: {open[-1]}")
logger.info(f"high: {high[-1]}")
logger.info(f"low: {low[-1]}")
logger.info(f"close: {close[-1]}")
logger.info(f"volume: {volume[-1]}")
#second last candle OHLCV values
logger.info(f"second last open: {open[-2]}")
logger.info(f"second last high: {high[-2]}")
logger.info(f"second last low: {low[-2]}")
logger.info(f"second last close: {close[-2]}")
logger.info(f"second last volume: {volume[-2]}")
# log history entry signals
logger.info(f"long_entry_hist: {self.long_entry_signal_history}")
logger.info(f"short_entry_hist: {self.short_entry_signal_history}")
def strategy(self, open, close, high, low, volume):
lot = self.exchange.get_lot()
lot = int(round(lot / 6, self.decimal_num))
resolution = self.input(defval=1, title="resolution", type=int)
variant_type = self.input(defval=5, title="variant_type", type=int)
basis_len = self.input(defval=19, title="basis_len", type=int)
fast_len = self.input("fast_len", int, 1)
slow_len = self.input("slow_len", int, 30)
trend_len = self.input("slow_len", int, 60)
longtrend_len = self.input("slow_len", int, 120)
source = self.exchange.security(str(resolution) + "m")
hadf = heikinashi(source)
hadf_fast = heikinashi(hadf)
ha_open_values = hadf_fast["HA_open"].values
ha_close_values = hadf_fast["HA_close"].values
variant = self.variants[variant_type]
ha_open_fast = variant(ha_open_values, fast_len)
ha_close_fast = variant(ha_close_values, fast_len)
haopen_fast = ha_open_fast[-1]
haclose_fast = ha_close_fast[-1]
haup_fast = haclose_fast > haopen_fast
hadown_fast = haclose_fast <= haopen_fast
# logger.info('haup_fast:%s\n' % haup_fast)
ha_open_slow = variant(ha_open_values, slow_len)
ha_close_slow = variant(ha_close_values, slow_len)
haopen_slow = ha_open_slow[-1]
haclose_slow = ha_close_slow[-1]
haup_slow = haclose_slow > haopen_slow
hadown_slow = haclose_slow <= haopen_slow
# logger.info('haup_slow:%s\n' % haup_slow)
ha_open_trend = variant(ha_open_values, trend_len)
ha_close_trend = variant(ha_close_values, trend_len)
haopen_trend = ha_open_trend[-1]
haclose_trend = ha_close_trend[-1]
haup_trend = haclose_trend > haopen_trend
hadown_trend = haclose_trend <= haopen_trend
# logger.info('haup_trend:%s\n' % haup_trend)
ha_open_longtrend = variant(ha_open_values, longtrend_len)
ha_close_longtrend = variant(ha_close_values, longtrend_len)
haopen_longtrend = ha_open_longtrend[-1]
haclose_longtrend = ha_close_longtrend[-1]
haup_longtrend = haclose_longtrend > haopen_longtrend
hadown_longtrend = haclose_longtrend <= haopen_longtrend
logger.info("ha_close_longtrend:%s\n" % ha_close_longtrend)
logger.info("ha_open_longtrend:%s\n" % ha_open_longtrend)
if not eval(os.environ.get("BOT_TEST", "False")):
"long"
self.exchange.entry("Long",
True,
lot,
when=crossover(ha_close_longtrend,
ha_open_longtrend))
" short "
self.exchange.entry(
"Short",
False,
lot,
when=crossunder(ha_close_longtrend, ha_open_longtrend),
)
def strategy(self, open, close, high, low, volume):
lot = self.exchange.get_lot()
lot = int(round(lot / 6, self.decimal_num))
price = self.exchange.get_market_price()
pos_size = self.exchange.get_position_size()
fast_len = self.input("fast_len", int,
int(os.environ.get("BOT_FAST_LEN", 5)))
slow_len = self.input("slow_len", int,
int(os.environ.get("BOT_SLOW_LEN", 18)))
trend_len = self.input("trend_len", int,
int(os.environ.get("BOT_TREND_LEN", 1200)))
fast_sma = sma(close, fast_len)
slow_sma = sma(close, slow_len)
trend_sma = sma(close, trend_len)
uptrend = True if trend_sma[-1] > trend_sma[-3] or trend_sma[
-1] > trend_sma[-10] else False
downtrend = True if trend_sma[-1] < trend_sma[-3] or trend_sma[
-1] < trend_sma[-10] else False
golden_cross = crossover(fast_sma, slow_sma)
dead_cross = crossunder(fast_sma, slow_sma)
nc = "golden" if round(fast_sma[-1] - slow_sma[-1],
self.price_decimal_num) < 0 else "dead"
ct = "sideways" if downtrend and uptrend else (
"down" if downtrend else "up")
np = "short" if nc == "golden" and (
pos_size > 0 or (pos_size >= 0 and downtrend)) else "long"
nt = "golden" if (nc == "golden" and np == "short") else (
"dead" if nc == "dead" and np == "long" else not nc)
logger.info(f"--------------------------------------")
logger.info(f"trend: {ct}")
logger.info(
f'next trade @ {nt} cross > {np} {lot} @ {calc_entry_price(price, False, self.price_decimal_num) if np == "short" else calc_entry_price(price, True, self.price_decimal_num)}'
)
if trend_sma[-1] != trend_sma[-1] or trend_sma[-3] != trend_sma[
-3] or trend_sma[-10] != trend_sma[-10]:
logger.info(f"--------------------------------------")
logger.info(f"Bot status: NEEDS RESTART")
# logger.info(f'--------------------------------------')
# logger.info(f'{abs(pos_size)}')
if not eval(os.environ.get("BOT_TEST", "False")):
if dead_cross and uptrend:
# self.exchange.cancel_orders_by_side('BUY')
self.exchange.order(
"Long",
True,
lot,
limit=calc_entry_price(price, True,
self.price_decimal_num),
when=True,
post_only=True,
)
logger.info("in dead_cross and uptrend for long")
if float(self.exchange.get_position()["notional"]) > 0.0:
self.exchange.order(
"Long",
False,
lot,
limit=calc_entry_price(price, False,
self.price_decimal_num),
when=golden_cross,
post_only=True,
)
if golden_cross and downtrend:
# self.exchange.cancel_orders_by_side('SELL')
self.exchange.entry(
"Short",
False,
lot,
limit=calc_entry_price(price, False,
self.price_decimal_num),
when=True,
post_only=True,
)
logger.info("in golden_cross and downtrend for short")
if float(self.exchange.get_position()["notional"]) < 0.0:
self.exchange.order(
"Short",
True,
lot,
limit=calc_entry_price(price, True,
self.price_decimal_num),
stop=(calc_entry_price(price, True,
self.price_decimal_num)),
when=dead_cross,
post_only=True,
)
def strategy(self, open, close, high, low, volume):
lot = self.exchange.get_lot()
lot = get_calc_lot(lot=lot,
decimal_num=self.decimal_num,
leverage=20.0,
actual_leverage=3.0)
fast_len = self.input("fast_len", int,
int(os.environ.get("BOT_FAST_LEN", 5)))
slow_len = self.input("slow_len", int,
int(os.environ.get("BOT_SLOW_LEN", 18)))
trend_len = self.input("trend_len", int, 90)
logger.info(f"fast_len: {fast_len}")
logger.info(f"slow_len: {slow_len}")
logger.info(f"trend_len: {trend_len}")
fast_sma = sma(close, fast_len)
slow_sma = sma(close, slow_len)
trend_sma = sma(close, trend_len)
uptrend = True if trend_sma[-1] > trend_sma[-3] or trend_sma[
-1] > trend_sma[-10] else False
downtrend = True if trend_sma[-1] < trend_sma[-3] or trend_sma[
-1] < trend_sma[-10] else False
golden_cross = crossover(fast_sma, slow_sma)
dead_cross = crossunder(fast_sma, slow_sma)
# inc_trend = fast_sma[-1] > slow_sma[-1]
# dec_trend = fast_sma[-1] < slow_sma[-1]
reward = self.risk * self.rr_ratio
self.exchange.sltp(
profit_long=reward,
profit_short=reward,
stop_long=self.risk,
stop_short=self.risk,
round_decimals=self.price_decimal_num,
)
# if float(self.exchange.get_position()['notional']) == 0.0:
if self.exchange.get_position_size() == 0.0:
self.exchange.cancel_all()
if golden_cross:
print("inc_trend detected")
while True:
# check if in long position
if float(self.exchange.get_position()
["notional"]) > 0.0 or downtrend:
print("long position opened")
break
print("trying to open long position...")
self.exchange.entry("Long", True, lot)
if dead_cross:
print("dec_trend detected")
while True:
# check if in short position
if float(self.exchange.get_position()
["notional"]) < 0.0 or uptrend:
print("short position opened")
break
print("trying to open short position...")
self.exchange.entry("Short", False, lot)
# OHLCV and indicator data, you can access history using list index
# log indicator values
print()
logger.info(f"fast_sma: {fast_sma[-1]}")
logger.info(f"slow_sma: {slow_sma[-1]}")
logger.info(f"trend_sma: {trend_sma[-1]}")
logger.info(f"uptrend: {uptrend}")
logger.info(f"downtrend: {downtrend}")
logger.info(f"golden_cross: {golden_cross}")
logger.info(f"dead_cross: {dead_cross}")
# log last candle OHLCV values
logger.info(f"open: {open[-1]}")
logger.info(f"high: {high[-1]}")
logger.info(f"low: {low[-1]}")
logger.info(f"close: {close[-1]}")
logger.info(f"volume: {volume[-1]}")
