def market_order_wait_till_execution(cls, side, size) -> dict:
id = cls.order(side, 0, size, 'market', 0)
i = 0
print('waiting order execution...')
flg_activated = False
time.sleep(1)
while True:
status = cls.get_order_status(id)
if len(status) > 0:
if status[0]['child_order_state'] == 'COMPLETED': # order executed
print('order has been executed')
return status[0]
elif status[0]['child_order_state'] == 'ACTIVE':
flg_activated = True
else:
if flg_activated:
print('order has been expired')
return None
i += 1
if i > 50:
print('market order wait till execution - ')
print(status[0])
LogMaster.add_log('market order wait till execution - ', 0, None)
LineNotification.send_error('market order wait till execution - ')
return status[0]
time.sleep(0.3)
def __display_thread(cls):
while SystemFlg.get_system_flg():
print('pl=', cls.total_pl, 'num_trade=', cls.num_trade,
'win_rate=', cls.win_rate, 'pl_per_min=', cls.pl_per_min,
'total_fee=', cls.total_fee)
print(cls.get_order_data())
print('holding_side=', cls.holding_side, 'holding_price',
cls.holding_price, 'holding_qty=', cls.holding_qty)
#LineNotification.send_message('holding_side:'+cls.holding_side+', holding_price:'+str(cls.holding_price)+', holding_qty:'+str(cls.holding_qty))
order_data = cls.get_order_data()
LineNotification.send_message('pl=' + str(cls.total_pl) +
', num_trade=' + str(cls.num_trade) +
', win_rate=' + str(cls.win_rate) +
'\n' + '********Holding********\n' +
cls.holding_side + ' @' +
str(cls.holding_price) + ' x ' +
str(cls.holding_qty) + '\n' +
'********Order********\n' +
str(order_data['side']) + ' @' +
str(order_data['price']) + ' x ' +
str(order_data['leaves_qty']))
LogMaster.add_account_log(datetime.datetime.now(),
Trade.get_bid_ask()[0], cls.total_pl,
cls.total_fee, cls.num_trade,
cls.win_rate)
#loop = asyncio.new_event_loop()
#loop.run_until_complete(cls.__generate_and_send_pl_image())
if cls.image_sending_flg >= 60:
cls.__generate_and_send_pl_image()
cls.image_sending_flg = 0
else:
cls.image_sending_flg += 1
time.sleep(60)
def entry_price_tracing_order(self, side, size):
ltp = TickData.get_ltp()
res, order_sizes, price, order_ids, total_executed = Trade.price_tracing_order(
side, size) # round(sum(exec_size), 2), ave_p, order_id
if res == 0:
print(side + ' entry price tracing order has been executed.' +
'price=' + str(price) + ', size=' + str(total_executed))
self.ac.add_orders(order_ids, order_sizes)
self.ac.add_order_exec_price_gap(price, ltp, side)
self.ac.calc_pl(side, price, total_executed)
print(
'holding_side={},holding_price={},holding_size={},total_pl={},collateral={},collateral_change={},realized_pl={}'
.format(self.ac.holding_side, self.ac.holding_price,
self.ac.holding_size, self.ac.total_pl,
self.ac.collateral, self.ac.collateral_change,
self.ac.realized_pl))
LogMaster.add_log(
'Price tracing order entry has been executed. ' + ' side=' +
side + ' size=' + str(size) + ' price=' + str(price),
self.prediction, self.ac)
else:
LogMaster.add_log(
'Limit order has been failed.' + ' side=' + side + ' ' +
str(total_executed), self.prediction, self.ac)
print('etnry price tracing order failed!')
def get_order_status(cls, id) -> []:
if cls.flg_api_limit == False:
res = []
try:
cls.num_private_access += 1
res = cls.bf.private_get_getchildorders(
params={
'product_code': 'FX_BTC_JPY',
'child_order_acceptance_id': id
})
except Exception as e:
if cls.check_exception(e) == 'ok':
pass
print('error in get_order_status ' + str(e))
LogMaster.add_log(
'api_error - Trade-get order status error! ' + str(e),
None)
LineNotification.send_error(
'api_error:Trade-get order status error!' + str(e))
finally:
return res
else:
print(
'get_order_status is temporary exhibited due to API access limitation!'
)
LogMaster.add_log(
'get_order_status is temporary exhibited due to API access limitation!',
None)
return None
def start_flyer_bot(self, num_term, window_term, pl, ls, upper_kijun,
lower_kijun):
self.__bot_initializer(num_term, window_term, pl, ls, upper_kijun,
lower_kijun)
self.start_time = time.time()
self.fixed_order_size = 0.05
while SystemFlg.get_system_flg():
self.__check_system_maintenance(num_term, window_term)
self.__update_ohlc()
if self.ac.holding_side == '' and self.ac.pt_side == '' and self.flg_loss_cut == False: #no position no pt order
if self.prediction == 1 or self.prediction == -1:
self.entry_price_tracing_order(self.pred_side,
self.fixed_order_size)
elif self.ac.holding_side != '' and self.ac.pt_side == '' and self.flg_loss_cut == False: #holding position and no order
self.entry_pt_order()
elif (self.ac.holding_side == 'buy' and self.prediction
== 2) or (self.ac.holding_side == 'sell' and self.prediction
== 1): # ポジションが判定と逆の時にexit, もしplがあればキャンセル。。
self.cancel_pt_order()
self.exit_order()
self.entry_price_tracing_order(self.pred_side,
self.fixed_order_size)
elif self.ac.holding_side == '' and self.ac.pt_side != '': #unexpected situation, no holding position but pt order exist
print('no position but pt order exist!')
LogMaster.add_log('no position but pt order exist!',
self.prediction, self.ac)
LineNotification.send_error('no position but pt order exist!')
self.cancel_pt_order()
self.check_and_do_lc() #check and do loss cut
if Trade.flg_api_limit:
time.sleep(60)
print('Bot sleeping for 60sec due to API access limitation')
else:
time.sleep(0.1)
def exit_order(self):
if self.ac.holding_side != '':
print('quick exit order')
side = 'buy' if self.ac.holding_side == 'sell' else 'sell'
ltp = TickData.get_ltp()
res, order_sizes, price, order_ids, total_executed = Trade.price_tracing_order(
side, self.ac.holding_size
) #return 0, round(sum(exec_size), 2), ave_p, order_id
if res == 0:
print(side + ' exit price tracing order has been executed.' +
'price=' + str(price) + ', size=' + str(total_executed))
self.ac.add_orders(order_ids, order_sizes)
self.ac.add_order_exec_price_gap(price, ltp, side)
self.ac.calc_pl(side, price, total_executed)
LogMaster.add_log('exit order completed!', self.prediction,
self.ac)
return 0
else:
print(side + ' exit price tracing order has been failed.' +
'price=' + str(price) + ', size=' + str(total_executed))
self.ac.add_orders(order_ids, order_sizes)
self.ac.add_order_exec_price_gap(price, ltp, side)
self.ac.calc_pl(side, price, total_executed)
LogMaster.add_log('exit order failed!', self.prediction,
self.ac)
return -1
def market_order_wait_till_execution3(cls, side, total_size):
size = []
price = []
max_wait = 10
num = 0
bid = TickData.get_bid_price()
ask = TickData.get_ask_price()
try:
cls.num_private_access += 1
order_id = cls.bf.create_order(
symbol='BTC/JPY',
type='market',
side=side,
amount=total_size,
params={'product_code': 'FX_BTC_JPY'})
except Exception as e:
print('market order failed! ' + str(e))
LogMaster.add_log('market order failed! ' + str(e), None)
LineNotification.send_error('market order failed! ' + str(e))
cls.check_exception(e)
return -1, 0, 0, ''
order_id = order_id['info']['child_order_acceptance_id']
print('waiting for market order execution...')
start = time.time()
while sum(size) < total_size:
exe_data = TickData.get_exe_data()[-100:]
if time.time() - start > max_wait:
exe_data = cls.get_executions()
exe_data = TickData.get_exe_data()[-100:]
for exec in exe_data:
if exec[side + "_child_order_acceptance_id"] == order_id:
size.append(exec["size"])
price.append(exec["price"])
if time.time() - start > max_wait:
print(
'can not complete Trade - check_and_wait_till_all_execution!'
)
LogMaster.add_log(
'can not complete Trade - check_and_wait_till_all_execution!',
None)
LineNotification.send_error(
'can not complete Trade - check_and_wait_till_all_execution!'
)
return -1, sum(size), round(
sum(price[i] * size[i]
for i in range(len(price))) / sum(size)), order_id
num += 1
ave_p = round(
sum(price[i] * size[i] for i in range(len(price))) / sum(size))
print('market order has been successfully executed.' + 'side=' + side +
', ave price=' + str(ave_p) + ', size=' +
str(round(sum(size), 2)))
sp = ask - ave_p if side == 'buy' else ave_p - bid
print('market order spread loss/profit = ' + str(sp))
cls.spread_loss_profit += sp
cls.spread_loss_profit_log.append(sp)
return 0, round(sum(size), 2), ave_p, order_id
def get_orders(cls):
try:
cls.num_private_access += 1
orders = cls.bf.fetch_open_orders(symbol='BTC/JPY', params={"product_code": "FX_BTC_JPY"})
except Exception as e:
print('error in get_orders ' + str(e))
LogMaster.add_log('api_error - Trade-get get_orders error! ' + str(e),0,None)
cls.check_exception(e)
time.sleep(3)
return cls.get_orders()
return orders
def cancel_and_wait_completion(cls, order_id):
cancel = cls.cancel_order(order_id)
if len(cancel) > 0:
if cancel['info']['ordStatus'] == 'Canceled':
return 0
else:
time.sleep(1)
return cls.cancel_and_wait_completion(order_id)
print('Trade - cancel_and_wait_completion - unexpected error!')
LogMaster.add_log({'dt': datetime.now(), 'api_error': 'Trade - cancel_and_wait_completion - unexpected error!'})
return -1
def get_current_asset(cls):
try:
cls.num_private_access += 1
res = cls.bf.fetch_balance()
except Exception as e:
print('error i get_current_asset ' + e)
LogMaster.add_log('action_message - Trade-get current asset error! ' + str(e),0,None)
LineNotification.send_error('action_message - Trade-get current asset error! ' + str(e))
if cls.check_exception(e) == 'ok':
pass
finally:
return res['total']['BTC'] * TickData.get_ltp() + res['total']['JPY']
def get_order(cls, order_id):
try:
cls.num_private_access += 1
order = cls.bf.fetch_open_orders(symbol='BTC/JPY', params={"product_code": "FX_BTC_JPY", 'child_order_acceptance_id': order_id})
except Exception as e:
print('error in get_order ' + str(e))
LogMaster.add_log('api_error - Trade-get get_order error! ' + str(e), None)
LineNotification.send_error('api_error - Trade-get get_order error! ' + str(e))
if cls.check_exception(e) == 'ok':
pass
else:
return cls.get_order(order_id)
return order
def calc_opt_pl(self):
if TickData.get_1m_std() > 10000:
newpl = self.pl_kijun * math.log(
(TickData.get_1m_std() / 100000)) + 5
print('changed opt pl kijun to ' + str(newpl))
LogMaster.add_log(
'action_message - changed opt pl kijun to ' + str(newpl),
self.prediction[0], self.ac)
LineNotification.send_error('changed opt pl kijun to ' +
str(newpl))
return newpl
else:
return self.pl_kijun
def get_positions(cls): # None
try:
cls.num_private_access += 1
positions = cls.bf.private_get_getpositions(params={"product_code": "FX_BTC_JPY"})
except Exception as e:
print('error in get_positions ' + str(e))
LogMaster.add_log('api_error - Trade-get get_positions error! ' + str(e),0,None)
LineNotification.send_error('api_error - Trade-get get_positions error! ' + str(e))
if cls.check_exception(e) == 'ok':
pass
else:
return cls.get_positions()
return positions
def get_collateral(cls):
res=''
try:
cls.num_private_access += 1
res = cls.bf.fetch2(path='getcollateral', api='private', method='GET')
except Exception as e:
print('error i get_collateral ' + e)
LogMaster.add_log('api_error - Trade-get get_collateral error! ' + str(e),0,None)
LineNotification.send_error('api_error - Trade-get get_collateral error! ' + str(e))
if cls.check_exception(e) == 'ok':
pass
finally:
return res
async def __send_performance_data(cls):
p = LogMaster.get_latest_performance()
pred = LogMaster.get_latest_position()
posi = LogMaster.get_latest_position()
if len(p) > 0:
await cls.__send_message('\r\n' + '[' +
str(p['dt'].strftime("%m/%d %H:%M:%S")) +
']' + '\r\n' + 'p:' + str(p['pnl']) +
', p-min:' + str(p['total_pnl_per_min']) +
', num:' + str(p['num_trade']) +
', rate:' + str(p['win_rate']) + '\r\n' +
str(posi['posi_side']) + ' : ' +
str(pred['prediction']))
def market_order_wait_till_execution2(cls, side, total_size):
size = []
price = []
wait_sec = 0.3
max_wait = 2.1
num = 0
try:
cls.num_private_access += 1
order_id = cls.bf.create_order(
symbol='BTC/JPY',
type='market',
side=side,
amount=total_size,
params={'product_code': 'FX_BTC_JPY'})
except Exception as e:
print('market order failed! ' + str(e))
LogMaster.add_log('market order failed! ' + str(e), None)
LineNotification.send_error('market order failed! ' + str(e))
cls.check_exception(e)
return -1, 0, 0, ''
order_id = order_id['info']['child_order_acceptance_id']
print('waiting for market order execution...')
while sum(size) < total_size:
executions = cls.get_executions()
for exec in executions:
if exec["child_order_acceptance_id"] == order_id:
size.append(exec["size"])
price.append(exec["price"])
time.sleep(wait_sec)
num += 1
if num * wait_sec > max_wait:
print(
'can not complete Trade - check_and_wait_till_all_execution!'
)
LogMaster.add_log(
'can not complete Trade - check_and_wait_till_all_execution!',
0, None)
LineNotification.send_error(
'can not complete Trade - check_and_wait_till_all_execution!'
)
return -1, sum(size), round(
sum(price[i] * size[i]
for i in range(len(price))) / sum(size)), order_id
ave_p = round(
sum(price[i] * size[i] for i in range(len(price))) / sum(size))
print('market order has been successfully executed.' + 'side=' + side +
', ave price=' + str(ave_p) + ', size=' +
str(round(sum(size), 2)))
return 0, round(sum(size), 2), ave_p, order_id
def calc_opt_size(self):
collateral = Trade.get_collateral()['collateral']
if TickData.get_1m_std() > 10000:
multiplier = 0.5
print('changed opt size multiplier to 0.5')
LogMaster.add_log(
'action_message - changed opt size multiplier to 0.5',
self.prediction[0], self.ac)
LineNotification.send_error('changed opt size multiplier to 0.5')
else:
multiplier = 1.5
size = round((multiplier * collateral * self.margin_rate) /
TickData.get_ltp() * 1.0 / self.leverage, 2)
return size
def cancel_order(self):
print('cancel order')
status = Trade.cancel_and_wait_completion(self.ac.order_id)
if len(status) > 0:
print('cancel failed, partially executed')
oid = Trade.order(status['side'].lower(), 0,
status['executed_size'], 'market', 1)
LogMaster.add_log(
'action_message - cancel order - cancel failed and partially executed. closed position.',
self.prediction[0], self.ac)
self.ac.initialize_order()
else:
LogMaster.add_log('action_message - cancelled order',
self.prediction[0], self.ac)
self.ac.initialize_order()
def cancel_order(cls, order_id):
cancel =''
try:
cls.num_private_access += 1
cancel = cls.bf.cancel_order(id=order_id, symbol='BTC/JPY', params={"product_code": "FX_BTC_JPY"})
except Exception as e:
print('error in cancel_order ' + str(e))
LogMaster.add_log('api_error - Trade-get cancel_order error! ' + str(e),0,None)
LineNotification.send_error('api_error - Trade-get cancel_order error! ' + str(e))
cls.check_exception(e)
if 'Order not found' in str(e):
print('cancel order not found!')
LogMaster.add_log('api_error - cancel order not found! ',0,None)
LineNotification.send_error('api_error - cancel order not found! ')
cancel = ''
return cancel
def __init__(self):
SystemFlg.initialize()
LineNotification.initialize()
Trade.initialize()
LogMaster.initialize()
while True:
print('Please select program mode.')
print('1: OHLCV data update')
print('2: Mark3etData test')
print('3: Bot test')
print('4: Sim')
print('5: WS Test')
print('6: Trade Test')
select = str(input())
if select == '1':
print('1: OHLCV data update')
dmd = DownloadMarketData()
dmd.download_all_targets_async(2017, 1, 2)
dmd.update_ohlcv()
RestAPI.update_onemin_data()
break
elif select == '2':
print('2: MarketData test')
term_list = list(range(10, 1000, 100))
MarketData.initialize_for_bot(term_list, True)
break
elif select == '3':
print('3: Bot test')
term_list = list(range(10, 1000, 100))
MarketData.initialize_for_bot(term_list, False)
bot = Bot(100)
break
elif select == '4':
print('4: Sim')
pass
break
elif select == '5':
print('5: WS Test')
pass
break
elif select == '6':
print('6: Trade Test')
Trade.test_trade()
break
else:
pass
def entry_pt_order(self):
side = 'buy' if self.ac.holding_side == 'sell' else 'sell'
price = self.ac.holding_price + self.pl if self.ac.holding_side == 'buy' else self.ac.holding_price - self.pl
res = Trade.order(side, price, self.ac.holding_size, 'limit', 1440)
if len(res) > 10:
self.ac.set_pt_order(res, side, self.ac.holding_size, price)
print('pl order: side = {}, price = {}, outstanding size = {}'.
format(self.ac.pt_side, self.ac.pt_price,
self.ac.pt_outstanding_size))
LogMaster.add_log(
'action_message - pl entry for ' + side + ' @' + str(price) +
' x' + str(self.ac.pt_outstanding_size), self.prediction,
self.ac)
else:
LogMaster.add_log('action_message - failed pl entry!',
self.prediction, self.ac)
print('failed pl order!')
def opt_price_wait_till_execution(cls, side, total_size):
exec_size = []
exec_price = []
max_wait = 2.1
loop_sec = 0.01
bid = TickData.get_bid_price()
ask = TickData.get_ask_price()
try:
price = TickData.get_bid_price() if side =='buy' else TickData.get_ask_price()
cls.num_private_access += 1
order_id = cls.bf.create_order(
symbol='BTC/JPY',
type='limit',
side=side,
price=price,
amount=total_size,
params={'product_code': 'FX_BTC_JPY', 'minute_to_expire': 1} # 期限切れまでの時間（分）（省略した場合は30日）
)
except Exception as e:
print('opt price order failed! ' + str(e))
LogMaster.add_log('opt price order failed! ' + str(e), 0, None)
LineNotification.send_error('opt price order failed! ' + str(e))
cls.check_exception(e)
return -1, 0, 0, ''
order_id = order_id['info']['child_order_acceptance_id']
print('waiting for opt price order execution...')
num = 0
ave_p = 0
while sum(exec_size) < total_size:
executions = cls.get_executions()
for exec in executions:
if exec["child_order_acceptance_id"] == order_id:
exec_size.append(exec["size"])
exec_price.append(exec["price"])
time.sleep(loop_sec)
num += 1
if max_wait < loop_sec * num:
cls.cancel_order(order_id)
if sum(exec_size) > 0:
ave_p = round(sum(exec_price[i] * exec_size[i] for i in range(len(exec_price))) / sum(exec_size))
print('opt price order has been failed.' + 'side=' + side + ', ave price=' + str(ave_p) + ', size=' + str(round(sum(exec_size), 2)))
return -1, round(sum(exec_size), 2), ave_p, order_id
ave_p = round(sum(exec_price[i] * exec_size[i] for i in range(len(exec_price))) / sum(exec_size))
print('opt price order has been successfully executed.' + 'side=' + side + ', ave price=' + str(ave_p) + ', size=' + str(round(sum(exec_size), 2)))
return 0, round(sum(exec_size), 2), ave_p, order_id
def cancel_order(cls, order_id):
for i in range(cls.error_trial):
cls.num_private_access += 1
cancel = ''
error_message = ''
try:
cancel = cls.bm.cancel_order(id=order_id, symbol='BTC/USD')
except Exception as e:
error_message = str(e)
print('error in cancel_order ' + str(e), cancel)
LogMaster.add_log({'dt': datetime.now(), 'api_error': 'Trade-get cancel_order error! ' + str(e)})
LineNotification.send_error('error in cancel order! ' + '\r\n' + cancel + '\r\n' + str(e))
finally:
if 'error' not in error_message:
return cancel
else:
time.sleep(cls.rest_interval)
return None
def entry_pl_order(self):
side = 'buy' if self.ac.holding_side == 'sell' else 'sell'
pl_kijun = self.calc_opt_pl()
price = self.ac.holding_price + pl_kijun if self.ac.holding_side == 'buy' else self.ac.holding_price - pl_kijun
res = Trade.order(side, price, self.ac.holding_size, 'limit', 1440)
if len(res) > 10:
self.ac.update_order(side, price, 0, self.ac.holding_size, res,
1440, 'pl order')
print('pl order: side = {}, price = {}, outstanding size = {}'.
format(self.ac.order_side, self.ac.order_price,
self.ac.order_outstanding_size))
LogMaster.add_log(
'action_message - pl entry for ' + side + ' @' + str(price) +
' x' + str(self.ac.order_outstanding_size), self.prediction[0],
self.ac)
else:
LogMaster.add_log('action_message - failed pl entry!',
self.prediction[0], self.ac)
print('failed pl order!')
def check_and_do_lc(self):
if self.ac.holding_side != '':
if self.ac.holding_side == 'buy' and TickData.get_ltp(
) - self.ac.holding_price <= -self.ls:
print('hit loss cut kijun')
LogMaster.add_log('hit loss cut kijun', self.prediction,
self.ac)
LineNotification.send_error('hit loss cut kijun')
self.flg_loss_cut = True
self.exit_order()
self.cancel_pt_order()
elif self.ac.holding_side == 'sell' and self.ac.holding_price - TickData.get_ltp(
) <= -self.ls:
print('hit loss cut kijun')
LogMaster.add_log('hit loss cut kijun', self.prediction,
self.ac)
LineNotification.send_error('hit loss cut kijun')
self.flg_loss_cut = True
self.exit_order()
self.cancel_pt_order()
def __bot_initializer(self, num_term, window_term, pl, ls, upper_kijun,
lower_kijun):
Trade.cancel_all_orders()
self.num_term = num_term
self.window_term = window_term
self.pl = pl
self.ls = ls
self.upper_kijun = upper_kijun
self.lower_kijun = lower_kijun
print('bot - updating crypto data..')
LogMaster.add_log('action_message - bot - updating crypto data..', 0,
self.ac)
CryptowatchDataGetter.get_and_add_to_csv()
self.last_ohlc_min = datetime.now(self.JST).minute - 1
print('bot - initializing MarketData..')
OneMinMarketData.initialize_for_bot(num_term, window_term)
print('bot - loading lgb model.')
self.model_buy, self.model_sell = self.lgb.load_model()
print('bot - started bot loop.')
LogMaster.add_log('action_message - bot - started bot loop.',
self.prediction, self.ac)
def entry_market_order(self, side, size):
if self.ac.order_side == '':
self.ac.update_order(side, 0, 0, size, '', 10, '')
ltp = TickData.get_ltp()
res, size, price, order_id = Trade.market_order_wait_till_execution3(
side, size)
if res == 0:
print(side + ' entry market order has been executed.' +
'price=' + str(price) + ', size=' + str(size))
self.ac.update_holding(side, price, size, order_id)
self.ac.sync_position_order()
self.ac.calc_collateral_change()
self.ac.calc_pl(TickData.get_ltp())
self.ac.add_order_exec_price_gap(price, ltp, side)
print(
'holding_side={},holding_price={},holding_size={},total_pl={},collateral={},collateral_change={},realized_pl={}'
.format(self.ac.holding_side, self.ac.holding_price,
self.ac.holding_size, self.ac.total_pl,
self.ac.collateral, self.ac.collateral_change,
self.ac.realized_pl))
LogMaster.add_log(
'Market order entry has been executed. ' + ' side=' +
side + ' size=' + str(size) + ' price=' + str(price),
self.prediction[0], self.ac)
else:
LogMaster.add_log(
'Market order has been failed.' + ' side=' + side + ' ' +
str(size), self.prediction[0], self.ac)
print('market order failed!')
self.ac.initialize_order()
else:
print('Entry market order - order is already exitst!')
LogMaster.add_log('Entry market order - order is already exitst!',
self.prediction[0], self.ac)
def __bot_initializer(self, num_term, window_term, pl_kijun,
future_period):
Trade.cancel_all_orders()
self.pl_kijun = pl_kijun
print('bot - updating crypto data..')
LogMaster.add_log('action_message - bot - updating crypto data..', 0,
self.ac)
CryptowatchDataGetter.get_and_add_to_csv()
self.last_ohlc_min = datetime.now(self.JST).minute - 1
print('bot - initializing MarketData..')
OneMinMarketData.initialize_for_bot(num_term, window_term,
future_period, pl_kijun,
num_term + 1)
#self.model = CatModel()
self.model = LgbModel()
print('bot - generating training data')
LogMaster.add_log('bot - training xgb model..', self.prediction[0],
self.ac)
print('bot - training model..')
#self.cbm = self.model.read_dump_model('./Model/cat_model.dat')
self.bst = self.model.load_model('./Model/lgb_model.dat')
print('bot - load cat model completed..')
print('bot - started bot loop.')
LogMaster.add_log('action_message - bot - started bot loop.',
self.prediction[0], self.ac)
def exit_order(self):
if self.ac.holding_side != '':
print('quick exit order')
status = Trade.market_order_wait_till_execution(
'buy' if self.ac.holding_side == 'sell' else 'sell',
self.ac.holding_size)
if status is not None:
if status['child_order_state'] == 'COMPLETED':
self.ac.initialize_holding()
print('exit order completed!')
LogMaster.add_log('exit order completed!',
self.prediction[0], self.ac)
return 0
else:
print('something wrong in exit order! ' + str(status))
LogMaster.add_log(
'something wrong in exit order! ' + str(status),
self.prediction[0], self.ac)
return -1
else:
print('something wrong in exit order! ' + str(status))
LogMaster.add_log(
'something wrong in exit order! ' + str(status),
self.prediction[0], self.ac)
return -1
def check_exception(cls, exc):
if 'Connection reset by peer' in str(exc):
print('detected connection reset by peer error!')
print('initialize trade class.')
LineNotification.send_error('detected connection reset by peer error!')
LogMaster.add_log('api_error - detected connection reset by peer error!',0,None)
cls.initialize()
time.sleep(10)
return 'error'
if 'Over API limit per minute' in str(exc):
print('API private access reached limitation!')
print('initialize trade class and sleep 60sec.')
LineNotification.send_error('API private access reached limitation!')
LogMaster.add_log('api_error - API private access reached limitation!',0,None)
cls.flg_api_limit = True
time.sleep(60)
cls.initialize()
return 'error'
if 'Connection aborted.' in str(exc):
print('Connection aborted error occurred!')
print('initialize trade class and sleep 5sec.')
LineNotification.send_error('Connection aborted.')
LogMaster.add_log('api_error - Connection aborted error occurred!',0,None)
cls.initialize()
time.sleep(5)
return 'error'
return 'ok'