def net_buy(custom_strategy): current_price = custom_strategy.exchange.get_instrument()['lastPrice'] logger.info("[net_order][normal_buy] current_price(2) : " + str(current_price)) default_Qty = settings.DEFAULT_ORDER_SIZE buy_level = math.ceil(settings.DEFAULT_ORDER_SPAN / 10) buy_orders = [] # manual #current_price = 9400.0 for i in range(1, buy_level + 1): for j in range(1, 21): #buy_orders.append({'price': current_price - ((j * 0.5) + (i - 1) * 10), 'orderQty': default_Qty * i, 'side': "Buy", 'execInst': "ParticipateDoNotInitiate"}) buy_orders.append({ 'price': current_price - ((j * 1.5) + (i - 1) * 30), 'orderQty': default_Qty * i, 'side': "Buy", 'execInst': "ParticipateDoNotInitiate" }) ret = custom_strategy.converge_orders(buy_orders, []) logger.info("[net_order][normal_buy] order length : " + str(len(ret))) logger.info("[net_order][normal_buy] MAX_ORDER_QUENTITY : " + str(settings.MAX_ORDER_QUENTITY)) singleton_data.getInstance().setAllowBuy(False) logger.info("[net_order][normal_buy] getAllowBuy() " + str(singleton_data.getInstance().getAllowBuy()))
def __init__(self, custom_strategy): logger.info("[BuyThread][run] __init__") threading.Thread.__init__(self) self.custom_strategy = custom_strategy singleton_data.getInstance().setAllowSell(False) singleton_data.getInstance().setBuyThread(True) # 70.0 * 2^n p = 2 ** int(singleton_data.getInstance().getAveDownCnt()) self.averagingUpSize = settings.AVERAGING_UP_SIZE * p logger.info("[BuyThread][run] averagingUpSize : " + str(self.averagingUpSize)) # default(20.0) * (current_quantity / max_order_quantity) # The maximum value is the default even if the quantity you have now is greater than max_order. # MAX = default(20.0) # The more net_buying orders, the higher the price. currentQty = self.custom_strategy.exchange.get_currentQty() logger.info("[BuyThread][run] MAX_ORDER_QUENTITY : " + str(settings.MAX_ORDER_QUENTITY)) self.minBuyingGap = 3.0 if abs(currentQty) > settings.MAX_ORDER_QUENTITY: self.minBuyingGap = self.minBuyingGap + settings.MIN_SELLING_GAP else : self.minBuyingGap = self.minBuyingGap + float(settings.MIN_SELLING_GAP) * float(abs(currentQty) / settings.MAX_ORDER_QUENTITY) logger.info("[BuyThread][run] minBuyingGap : " + str(self.minBuyingGap)) self.waiting_buy_order = {} self.wait_cnt = 0
def __init__(self, custom_strategy, order_type): logger.info("[OrderThread][run] __init__") threading.Thread.__init__(self) self.custom_strategy = custom_strategy self.order_type = order_type self.lastClosePrice = self.custom_strategy.analysis_30m['Close'] singleton_data.getInstance().setOrderThread(True) currentQty = self.custom_strategy.exchange.get_currentQty() logger.info("[OrderThread][run] currentQty : " + str(currentQty)) self.waiting_order = {}
def check_sell_order(self, avgCostPrice): # checking whether or not it's sold ret = False sell_orders = self.custom_strategy.exchange.get_orders('Sell') logger.info("[SellThread][check_sell_order] sell_orders : " + str(sell_orders)) if len(sell_orders) == 0: # selling complete logger.info("[SellThread][check_sell_order] selling complete!") self.custom_strategy.exchange.cancel_all_orders('All') singleton_data.getInstance().setAveDownCnt(0) # expectedProfit 수정 필요 #logger.info("[SellThread][check_sell_order] ###### profit : + " + str(self.expectedProfit) + "$ ######") #execute_logger.info("###### profit : + " + str(self.expectedProfit) + "$ ######") ret = True self.waiting_sell_order = {} elif len(sell_orders) == 1: current_price = self.custom_strategy.exchange.get_instrument( )['lastPrice'] if not float(current_price) > float(avgCostPrice) + float( self.minSellingGap): logger.info("[SellThread][check_sell_order] current_price(" + str(current_price) + ") > avgCostPrice(" + str(avgCostPrice) + ") + minSellingGap(" + str(self.minSellingGap) + ")") self.waiting_sell_order = {} self.custom_strategy.exchange.cancel_all_orders('Sell') ret = False # 3.0 move to settings elif float(sell_orders[0]['price']) - float(current_price) > 3.0: # flee away 3$ form first oder_price, amend order # reorder self.waiting_sell_order = self.make_sell_order() logger.info( "[SellThread][check_sell_order] reorder current_price - 3$ : waiting_sell_order : " + str(self.waiting_sell_order)) else: logger.info( "[SellThread][check_sell_order] The price you ordered has not dropped by more than $ 3 from the current price." ) logger.info("[SellThread][check_sell_order] not yet selling") return ret
def get_tradeBin(self, bidSize='1m'): update_required = False #logger.info("[ExchangeInterface][get_tradeBin1m]") if bidSize == '1m' or bidSize == '5m': bin_data = self.bitmex.get_trade_bin(bidSize) update_required = singleton_data.getInstance().appendOHLC_data( bin_data, bidSize) return update_required
def animate(self, i): #logger.info("[plotThread][animate] self.update_flag " + str(self.update_flag)) if self.update_flag: sec_id = singleton_data.getInstance().getOHLC_data() sec_id_ochl = np.array(pd.DataFrame({'0':date2num(sec_id.index), '1':sec_id.open, '2':sec_id.close, '3':sec_id.high, '4':sec_id.low})) #logger.info("[plotThread][animate] sec_id_ochl " + str(sec_id_ochl)) self.analysis = pd.DataFrame(index = sec_id.index) self.analysis['sma_f'] = sec_id.close.rolling(self.SMA_FAST).mean() self.analysis['sma_s'] = sec_id.close.rolling(self.SMA_SLOW).mean() self.analysis['rsi'] = ta.RSI(sec_id.close.to_numpy(), self.RSI_PERIOD) self.analysis['sma_r'] = self.analysis.rsi.rolling(self.RSI_PERIOD).mean() self.analysis['macd'], self.analysis['macdSignal'], self.analysis['macdHist'] = ta.MACD(sec_id.close.to_numpy(), fastperiod=self.MACD_FAST, slowperiod=self.MACD_SLOW, signalperiod=self.MACD_SIGNAL) self.analysis['stoch_k'], self.analysis['stoch_d'] = ta.STOCH(sec_id.high.to_numpy(), sec_id.low.to_numpy(), sec_id.close.to_numpy(), fastk_period=5, slowk_period=3, slowk_matype=0, slowd_period=3, slowd_matype=0)#slowk_period=self.STOCH_K, slowd_period=self.STOCH_D) self.analysis['sma'] = np.where(self.analysis.sma_f > self.analysis.sma_s, 1, 0) # Plot candles width=.6/(24*60) candlestick(self.ax1, sec_id_ochl, width=.6/(24*60), colorup='g', colordown='r', alpha=1) # Draw Moving Averages self.analysis['sma_f'] = sec_id.close.rolling(self.SMA_FAST).mean() self.analysis['sma_s'] = sec_id.close.rolling(self.SMA_SLOW).mean() self.analysis.sma_f.plot(ax=self.ax1, c='r', linewidth=self.LINE_WIDTH) self.analysis.sma_s.plot(ax=self.ax1, c='g', linewidth=self.LINE_WIDTH) self.analysis.rsi.plot(ax = self.ax2, c='g', label = 'Period: ' + str(self.RSI_PERIOD), linewidth=self.LINE_WIDTH) self.analysis.sma_r.plot(ax = self.ax2, c='r', label = 'MA: ' + str(self.RSI_AVG_PERIOD), linewidth=self.LINE_WIDTH) self.analysis.macd.plot(ax=self.ax3, color='b', label='Macd', linewidth=self.LINE_WIDTH) self.analysis.macdSignal.plot(ax=self.ax3, color='g', label='Signal', linewidth=self.LINE_WIDTH) self.analysis.macdHist.plot(ax=self.ax3, color='r', label='Hist', linewidth=self.LINE_WIDTH) self.analysis.stoch_k.plot(ax=self.ax4, label='stoch_k:'+ str(self.STOCH_K), color='r', linewidth=self.LINE_WIDTH) self.analysis.stoch_d.plot(ax=self.ax4, label='stoch_d:'+ str(self.STOCH_D), color='g', linewidth=self.LINE_WIDTH) self.update_flag = False
def run(self): logger.info("[OrderThread][run]") while singleton_data.getInstance().getAllowOrder(): try: # realized profit current_price = self.custom_strategy.exchange.get_instrument( )['lastPrice'] avgCostPrice = self.custom_strategy.exchange.get_avgCostPrice() currentQty = self.custom_strategy.exchange.get_currentQty() logger.info("[OrderThread][run] current_price : " + str(current_price) + ", avgCostPrice : " + str(avgCostPrice) + ", currentQty : " + str(currentQty)) if len(self.waiting_order) == 0: # ordering condition self.waiting_order = self.make_order() logger.info("[OrderThread][run] NEW : waiting_order : " + str(self.waiting_order)) #check ordering elif len(self.waiting_order) > 0: if self.check_order(): singleton_data.getInstance().setAllowOrder(False) break else: logger.info("[OrderThread][run] len(waiting_order) : " + str(len(self.waiting_order))) logger.info("[OrderThread][run] waiting_order : " + str(self.waiting_order)) sleep(1) except Exception as ex: self.PrintException() break sleep(1) # Cancel all orders self.custom_strategy.exchange.cancel_all_orders('All') singleton_data.getInstance().setAllowOrder(True) singleton_data.getInstance().setOrderThread(False) singleton_data.instance().setSwitchMode(False)
def run(self): logger.info("[BuyThread][run]") while not singleton_data.getInstance().getAllowBuy(): try: # realized profit current_price = self.custom_strategy.exchange.get_instrument()['lastPrice'] avgCostPrice = self.custom_strategy.exchange.get_avgCostPrice() currentQty = self.custom_strategy.exchange.get_currentQty() logger.info("[BuyThread][run] current_price : " + str(current_price) + ", avgCostPrice : " + str(avgCostPrice) + ", currentQty : " + str(currentQty)) if len(self.waiting_buy_order) == 0: # buying condition if float(current_price) < float(avgCostPrice) - float(self.minBuyingGap): logger.info("[BuyThread][run] current_price(" + str(current_price) +") < avgCostPrice(" + str(avgCostPrice) + ") - minBuyingGap(" + str(self.minBuyingGap) + ")") self.waiting_buy_order = self.make_buy_order() logger.info("[BuyThread][run] NEW : waiting_buy_order : " + str(self.waiting_buy_order)) # waiting (default:120) secs condition elif float(current_price) < float(avgCostPrice): self.wait_cnt += 1 if self.wait_cnt > settings.SELLING_WAIT: logger.info("[BuyThread][run] stop buying thread because cnt < " + str(settings.SELLING_WAIT)) logger.info("[BuyThread][run] wait_cnt : " + str(self.wait_cnt)) logger.info("[BuyThread][run] current_price : " + str(current_price) + ", avgCostPrice : " + str(avgCostPrice) + ", currentQty : " + str(currentQty)) break # exit buy thread else : # check Additional buying # # even though buying in not allow, # ave_price largger that cur_price + averagingUpSize(default : 50$), making ave_down #logger.info("[BuyThread][run] current_price + averagingUpSize < avgCostPrice : " + str(float(current_price) + float(self.averagingUpSize) < float(avgCostPrice))) if float(current_price) > float(avgCostPrice) + float(self.averagingUpSize): buy_orders = self.custom_strategy.exchange.get_orders('Buy') if len(buy_orders) > 0: logger.info("[BuyThread][run] Additional selling fail because remaining buy orders : " + str(buy_orders)) else : logger.info("[BuyThread][run] ##### Additional Selling #####") logger.info("[BuyThread][run] current_price > avgCostPrice + + averagingUpSize(" + str(self.averagingUpSize) + ")") logger.info("[BuyThread][run] current_price : " + str(current_price) + ", avgCostPrice : " + str(avgCostPrice)) aveCnt = singleton_data.getInstance().getAveDownCnt() + 1 singleton_data.getInstance().setAveDownCnt(aveCnt) logger.info("[BuyThread][run] aveCnt : " + str(aveCnt)) singleton_data.getInstance().setAllowSell(True) else : logger.info("[BuyThread][run] Not yet additional buying") break #check buying order elif len(self.waiting_buy_order) > 0: if self.check_buy_order(avgCostPrice): singleton_data.getInstance().setAllowSell(True) break else : logger.info("[BuyThread][run] len(waiting_buy_order) : " + str(len(self.waiting_buy_order))) logger.info("[BuyThread][run] waiting_buy_order : " + str(self.waiting_buy_order)) sleep(1) except Exception as ex: self.PrintException() break logger.info("[BuyThread][run] wait_cnt : " + str(self.wait_cnt)) sleep(1) # Cancel all buy orders try: self.custom_strategy.exchange.cancel_all_orders('Buy') except Exception as ex: self.PrintException() finally: singleton_data.getInstance().setBuyThread(False)
def run(self): logger.info("[bitmex_plot][run]") sec_id = singleton_data.getInstance().getOHLC_data() self.sec_id_ochl = np.array(pd.DataFrame({'0':date2num(sec_id.index),#.to_pydatetime()), '1':sec_id.open, '2':sec_id.close, '3':sec_id.high, '4':sec_id.low})) #self.analysis.Date.dt.tz_localize('UTC') self.analysis = analysis.get_analysis(False) # Prepare plot self.fig, (self.ax1, self.ax2, self.ax3, self.ax4) = plt.subplots(4, 1, sharex=True) self.ax1.set_ylabel(ticker, size=20) self.ax1.xaxis.set_major_formatter(matplotlib.dates.DateFormatter('%H:%M:%S')) #size plot self.fig.set_size_inches(15,30) # Plot candles width=.6/(24*60) candlestick(self.ax1, self.sec_id_ochl, width=.6/(24*60), colorup='g', colordown='r', alpha=1) # Draw Moving Averages self.analysis.sma_f.plot(ax=self.ax1, c='r', linewidth=self.LINE_WIDTH) self.analysis.sma_s.plot(ax=self.ax1, c='g', linewidth=self.LINE_WIDTH) handles, labels = self.ax1.get_legend_handles_labels() self.ax1.legend(handles, labels) #RSI self.ax2.set_ylabel('RSI', size=self.Y_AXIS_SIZE) self.analysis.rsi.plot(ax = self.ax2, c='g', label = 'Period: ' + str(self.RSI_PERIOD), linewidth=self.LINE_WIDTH) self.analysis.sma_r.plot(ax = self.ax2, c='r', label = 'MA: ' + str(self.RSI_AVG_PERIOD), linewidth=self.LINE_WIDTH) self.ax2.axhline(y=30, c='b', linewidth=self.LINE_WIDTH) #self.ax2.axhline(y=50, c='black', linewidth=self.LINE_WIDTH) self.ax2.axhline(y=70, c='b', linewidth=self.LINE_WIDTH) self.ax2.set_ylim([0,100]) handles, labels = self.ax2.get_legend_handles_labels() self.ax2.legend(handles, labels) # Draw MACD computed with Talib self.ax3.set_ylabel('MACD: '+ str(self.MACD_FAST) + ', ' + str(self.MACD_SLOW) + ', ' + str(self.MACD_SIGNAL), size=self.Y_AXIS_SIZE) self.analysis.macd.plot(ax=self.ax3, color='b', label='Macd', linewidth=self.LINE_WIDTH) self.analysis.macdSignal.plot(ax=self.ax3, color='g', label='Signal', linewidth=self.LINE_WIDTH) self.analysis.macdHist.plot(ax=self.ax3, color='r', label='Hist', linewidth=self.LINE_WIDTH) self.ax3.axhline(0, lw=2, color='0', linewidth=self.LINE_WIDTH) handles, labels = self.ax3.get_legend_handles_labels() self.ax3.legend(handles, labels) # Stochastic plot self.ax4.set_ylabel('Stoch (k,d)', size=self.Y_AXIS_SIZE) self.analysis.stoch_k.plot(ax=self.ax4, label='stoch_k:'+ str(self.STOCH_K), color='r', linewidth=self.LINE_WIDTH) self.analysis.stoch_d.plot(ax=self.ax4, label='stoch_d:'+ str(self.STOCH_D), color='g', linewidth=self.LINE_WIDTH) handles, labels = self.ax4.get_legend_handles_labels() self.ax4.legend(handles, labels) self.ax4.axhline(y=20, c='b', linewidth=self.LINE_WIDTH) self.ax4.axhline(y=50, c='black', linewidth=self.LINE_WIDTH) self.ax4.axhline(y=80, c='b', linewidth=self.LINE_WIDTH) self.ani = animation.FuncAnimation(self.fig, self.animate, interval=5000) plt.show()
def get_analysis(getOnlyLast=False, bidSize='1m'): sec_id = None if bidSize == '1m': sec_id = singleton_data.getInstance().getOHLC_1m_data() elif bidSize == '5m': sec_id = singleton_data.getInstance().getOHLC_5m_data() elif bidSize == '30m': bin5m_data = singleton_data.getInstance().getOHLC_5m_data() first_idx, last_idx = trim_30m(bin5m_data) logger.info("[get_analysis] len(bin5m_data) " + str(len(bin5m_data))) temp_list = [] for i in range(first_idx, last_idx + 1): if not i % 6 == first_idx: continue temp_map = {} temp_map['trades'] = 0 temp_map['volume'] = 0 temp_map['high'] = bin5m_data['high'][i] temp_map['low'] = bin5m_data['low'][i] temp_map['timestamp'] = bin5m_data['timestamp'][i] temp_map['symbol'] = bin5m_data['symbol'][i] temp_map['open'] = bin5m_data['open'][i] temp_map['close'] = bin5m_data['close'][i + 5] for j in range(i, i + 6): if temp_map['high'] < bin5m_data['high'][j]: temp_map['high'] = bin5m_data['high'][j] if temp_map['low'] > bin5m_data['low'][j]: temp_map['low'] = bin5m_data['low'][j] temp_map[ 'trades'] = temp_map['trades'] + bin5m_data['trades'][j] temp_map['volume'] = bin5m_data['volume'][i] + bin5m_data[ 'volume'][j] temp_list.append(temp_map) cnt = int((last_idx + 1 - first_idx) / 6) df = pd.DataFrame( { 'timestamp': [temp_list[i]['timestamp'] for i in range(0, cnt)], 'symbol': [temp_list[i]['symbol'] for i in range(0, cnt)], 'open': [temp_list[i]['open'] for i in range(0, cnt)], 'high': [temp_list[i]['high'] for i in range(0, cnt)], 'low': [temp_list[i]['low'] for i in range(0, cnt)], 'close': [temp_list[i]['close'] for i in range(0, cnt)], 'trades': [temp_list[i]['trades'] for i in range(0, cnt)], 'volume': [temp_list[i]['volume'] for i in range(0, cnt)], }, index=pd.to_datetime( [temp_list[i]['timestamp'] for i in range(0, cnt)])) sec_id = df #analysis = pd.DataFrame(index = date2num(sec_id.index)) analysis = pd.DataFrame() ret = [] analysis['timestamp'] = sec_id.timestamp analysis['Open'] = sec_id.open.to_numpy() analysis['High'] = sec_id.high.to_numpy() analysis['Low'] = sec_id.low.to_numpy() analysis['Close'] = sec_id.close.to_numpy() analysis = getSuperTrend(analysis, 2, 16) #analysis['sma_f'] = sec_id.close.rolling(SMA_FAST).mean() #analysis['sma_s'] = sec_id.close.rolling(SMA_SLOW).mean() analysis['rsi'] = ta.RSI(sec_id.close.to_numpy(), RSI_PERIOD) #analysis['sma_r'] = analysis.rsi.rolling(RSI_PERIOD).mean() #analysis['macd'], analysis['macdSignal'], analysis['macdHist'] = ta.MACD(sec_id.close.to_numpy(), fastperiod=MACD_FAST, slowperiod=MACD_SLOW, signalperiod=MACD_SIGNAL) analysis['stoch_k'], analysis['stoch_d'] = ta.STOCH( sec_id.high.to_numpy(), sec_id.low.to_numpy(), sec_id.close.to_numpy(), fastk_period=5, slowk_period=3, slowk_matype=0, slowd_period=3, slowd_matype=0) #slowk_period=self.STOCH_K, slowd_period=self.STOCH_D) #analysis['sma'] = np.where(analysis.sma_f > analysis.sma_s, 1, 0) ret = analysis if (getOnlyLast): ret = analysis.iloc[-1:] return ret