def analyze_ticker(self, pair, data): '''analyze tick data''' if pair == RTAPI.TradePair.BTC_JPY.value: self.dsc_sfd.update_date_spot(n2d(data.ltp)) elif pair == RTAPI.TradePair.FX_BTC_JPY.value: self.dsc_tick_fx.update_date(data) self.dsc_sfd.update_date_fx(n2d(data.ltp))
def __init__(self, mid_price, depth_asks, depth_bids, amount_filter_ask, amount_filter_bid): self.amount_filter_ask = amount_filter_ask self.amount_filter_bid = amount_filter_bid # for ask self.ask_idx = self.__get_filter_top_idx(depth_asks, n2d(amount_filter_ask)) self.ask_price = depth_asks[self.ask_idx][0] self.ask_amount = self.__get_amount_in_range( depth_asks, depth_asks[0][0], self.ask_price) self.ask_spread = self.ask_price - mid_price # for bid self.bid_idx = self.__get_filter_top_idx(depth_bids, n2d(amount_filter_bid)) self.bid_price = depth_bids[self.bid_idx][0] self.bid_amount = self.__get_amount_in_range( depth_bids, depth_bids[0][0], self.bid_price) self.bid_spread = mid_price - self.bid_price # spread self.spread = self.ask_price - self.bid_price self.percentage = ( (self.ask_price / self.bid_price) - n2d(1.0)) * n2d(100.0) self.amount = self.ask_amount + self.bid_amount
def __init__(self): self.SFD_DECISION_TABLE = ( (n2d(0.05), n2d(0.0000) ), # Level0: At least 0% but less than 5% 0.00% of the settlement ( n2d(0.10), n2d(0.0025) ), # Level1: At least 5% but less than 10% 0.25% of the settlement ( n2d(0.15), n2d(0.0050) ), # Level2: At least 10% but less than 15% 0.50% of the settlement ( n2d(0.20), n2d(0.0100) ), # Level3: At least 15% but less than 20% 1.00% of the settlement (None, n2d(0.0200)), # Level4: At least 20% 2.00% of the settlement ) self.price_disparity_rate = None self.sfd_rate = None self.sfd_level = None self.occur_price_buy = None self.occur_price_sell = None self.spot_lpt = None self.fx_lpt = None
def __update_depth(self, raw_list, depth_list, diff, asc, mpf): # make new list by numpy new_list = depth_list for data in raw_list: # get each detail data new_price = n2d(data['price']) new_amount = n2d(data['size']) # delete old data (only diff mode) if diff: new_list = np.delete(new_list, np.where(depth_list[:, 0] == new_price), axis=0) # add new data if new_amount != 0: new_list = np.append(new_list, np.array([[new_price, new_amount]]), axis=0) # sort depth by price and adjust array length and mid price filter if asc: # for ask new_list = new_list[np.argsort(new_list[:, 0])] if new_list.shape[0] > self.PRM_MAX_LEN: new_list = np.delete( new_list, np.where( new_list[:, 0] >= new_list[self.PRM_MAX_LEN - 1][0]), axis=0) if mpf: new_list = np.delete( new_list, np.where(new_list[:, 0] <= self.mid_price), axis=0) else: # for bid new_list = new_list[np.argsort(new_list[:, 0])[::-1]] if new_list.shape[0] > self.PRM_MAX_LEN: new_list = np.delete( new_list, np.where( new_list[:, 0] <= new_list[self.PRM_MAX_LEN - 1][0]), axis=0) if mpf: new_list = np.delete( new_list, np.where(new_list[:, 0] >= self.mid_price), axis=0) # return new list return new_list
def __init__(self, depth_asks, depth_bids, amount_filter_ask, amount_filter_bid): self.amount_filter_ask = amount_filter_ask self.amount_filter_bid = amount_filter_bid self.idx_ask = self.__get_filter_top_idx(depth_asks, n2d(amount_filter_ask)) self.idx_bid = self.__get_filter_top_idx(depth_bids, n2d(amount_filter_bid)) self.price_ask = depth_asks[self.idx_ask][0] self.price_bid = depth_bids[self.idx_bid][0] self.spread = self.price_ask - self.price_bid self.spread_rate = (self.price_ask / self.price_bid) - n2d(1.0)
def _query_data(target_list, prm_range): if len(target_list) > 0: sum_amount = n2d(0.0) query_list = [ td for td in target_list if td[self.TRADE_ARRAY.TIME] >= prm_range ] for exec_data in query_list: sum_amount += exec_data[self.TRADE_ARRAY.AMOUNT] return sum_amount return n2d(0.0)
def __init__(self, depth_data): if len(depth_data[:, 1]) > 0: self.am_min = np.min(depth_data[:, 1], axis=0) self.am_max = np.max(depth_data[:, 1], axis=0) self.am_sum = np.sum(depth_data[:, 1], axis=0) self.am_mean = np.mean(depth_data[:, 1], axis=0) self.am_median = np.median(depth_data[:, 1], axis=0) else: self.am_min = n2d(0.0) self.am_max = n2d(0.0) self.am_sum = n2d(0.0) self.am_mean = n2d(0.0) self.am_median = n2d(0.0)
def __update_occur_price(self): if self.spot_lpt is None: self.occur_price_buy = None self.occur_price_sell = None return self.occur_price_buy = [dfloor(self.spot_lpt, 0)] self.occur_price_sell = [dceiling(self.spot_lpt, 0)] for row in self.SFD_DECISION_TABLE: if row[0] is not None: self.occur_price_buy.append( dfloor(self.spot_lpt * (n2d(1) - row[0]), 0)) self.occur_price_sell.append( dceiling(self.spot_lpt * (n2d(1) + row[0]), 0))
def __update_sfd_date(self): if (self.spot_lpt is None or self.fx_lpt is None): self.price_disparity_rate = None self.sfd_rate = None return self.price_disparity_rate = (self.fx_lpt / self.spot_lpt) - n2d(1.0) self.sfd_rate = n2d(0.0) self.sfd_level = 0 for row in self.SFD_DECISION_TABLE: if row[0] is None or self.price_disparity_rate < row[0]: self.sfd_rate = row[1] break self.sfd_level += 1
def __add_data(self, exec_data): wk_utc_dt = datetime.strptime(exec_data.exec_date[0:22], self.BROKER_TIMESTAMP_FORMAT) val_dt = wk_utc_dt + timedelta(hours=9) val_price = n2d(exec_data.price) val_amount = n2d(exec_data.size) val_buy_id = exec_data.buy_child_order_acceptance_id val_sell_id = exec_data.sell_child_order_acceptance_id if exec_data.side == "BUY": self.buys.append( [val_dt, val_price, val_amount, val_buy_id, val_sell_id]) elif exec_data.side == "SELL": self.sells.append( [val_dt, val_price, val_amount, val_buy_id, val_sell_id]) self.event_values.append([val_dt, val_price, val_amount])
def check_exec_buy(self, oid) -> (Decimal, Decimal): '''check the execution of buy order''' price_list = [] amount_list = [] total_price = n2d(0.0) total_amount = n2d(0.0) for datas in self.buys: # taker if datas[self.TRADE_ARRAY.BUY_ID] == oid: price_list.append(datas[self.TRADE_ARRAY.PRICE]) amount_list.append(datas[self.TRADE_ARRAY.AMOUNT]) for datas in self.sells: # maker if datas[self.TRADE_ARRAY.BUY_ID] == oid: price_list.append(datas[self.TRADE_ARRAY.PRICE]) amount_list.append(datas[self.TRADE_ARRAY.AMOUNT]) total_amount = sum(amount_list) for part_price, part_amount in zip(price_list, amount_list): total_price += (part_price * (part_amount / total_amount)) return dfloor(total_price, 0), total_amount
def update_date(self, raw_executions_list): '''update data''' # init value self.last_amount = n2d(0.0) # check start time if self.__range_start_dt is None: self.__range_start_dt = self.__adjtime.get_now() # add new data self.event_values = [] for exec_data in raw_executions_list: self.__add_data(exec_data) self.last_amount += n2d(exec_data.size) # remove out of range data self.__remove_rangeout_data() # get the last tread info wk_utc = datetime.strptime(raw_executions_list[-1].exec_date[0:23], self.BROKER_TIMESTAMP_FORMAT) self.last_dt = wk_utc + timedelta(hours=9) self.last_price = n2d(raw_executions_list[-1].price)
def update_date(self, data: RTAPI.TickerData): '''update data''' self.__available = False wk_utc_dt = datetime.strptime(data.timestamp[0:23], self.BROKER_TIMESTAMP_FORMAT) self.ts_dt = wk_utc_dt + timedelta(hours=9) self.bid_price = n2d(data.best_bid) self.ask_price = n2d(data.best_ask) self.bid_amount = n2d(data.best_bid_size) self.ask_amount = n2d(data.best_ask_size) self.total_bid_amount = n2d(data.total_bid_depth) self.total_ask_amount = n2d(data.total_ask_depth) self.trade_price = n2d(data.ltp) self.trade_volume_24h = n2d(data.volume_by_product) self.spread = self.ask_price - self.bid_price self.spread_rate = (self.ask_price / self.bid_price) - n2d(1.0) self.__update_tick_data_list(self.ts_dt, self.trade_price) self.__available = True
def get_range_depth(self, price_range): '''get range depth data''' # check data available if not self.is_available(): return None, None range_ask_from = self.mid_price range_ask_to = self.mid_price + n2d(price_range) query_asks = self.asks[np.where(((self.asks[:, 0] >= range_ask_from) & (self.asks[:, 0] < range_ask_to)))] range_bid_from = self.mid_price range_bid_to = self.mid_price - price_range query_bids = self.bids[np.where(((self.bids[:, 0] <= range_bid_from) & (self.bids[:, 0] > range_bid_to)))] return query_asks, query_bids
def update_data(self, raw_mid_price, raw_ask_list, raw_bid_list, mpf=True): '''update data (for differential data)''' # initial check if self.asks is None or self.bids is None: return # set mid price self.mid_price = n2d(raw_mid_price) # set ask depth self.asks = self.__update_depth(raw_ask_list, self.asks, diff=True, asc=True, mpf=mpf) # set bid depth self.bids = self.__update_depth(raw_bid_list, self.bids, diff=True, asc=False, mpf=mpf)
def init_data(self, raw_mid_price, raw_ask_list, raw_bid_list, mpf=True): '''initialize data (for snapshot data)''' # set mid price self.mid_price = n2d(raw_mid_price) # set ask depth if len(raw_ask_list) > 0: self.asks = self.__mk_empty_depth_data() self.asks = self.__update_depth(raw_ask_list, self.asks, diff=False, asc=True, mpf=mpf) # set bid depth if len(raw_bid_list) > 0: self.bids = self.__mk_empty_depth_data() self.bids = self.__update_depth(raw_bid_list, self.bids, diff=False, asc=False, mpf=mpf)
def price_disparity_per(self): '''price disparity (unit percent) ''' if self.price_disparity_rate is None: return None return self.price_disparity_rate * n2d(100.0)
def sfd_per(self): '''sfd (unit percent) ''' if self.sfd_rate is None: return None return self.sfd_rate * n2d(100.0)
def __analize_data(self, tick_list: list): if tick_list is None or len(tick_list) <= 0: return tick_list.sort(key=itemgetter(DatasetTick.TRADE_PRICE_ARRAY.TIME)) __price_list = [ row[DatasetTick.TRADE_PRICE_ARRAY.PRICE] for row in tick_list ] self.p_open = n2d(__price_list[0]) self.p_close = n2d(__price_list[-1]) self.p_high = n2d(max(__price_list)) self.p_low = n2d(min(__price_list)) self.r_hight = n2d(self.p_high - self.p_low) if self.p_open < self.p_close: self.c_white = True self.c_black = False self.r_body = n2d(self.p_close - self.p_open) self.r_upper_shadow = n2d(self.p_high - self.p_close) self.r_lower_shadow = n2d(self.p_open - self.p_low) self.p_body_high = self.p_close self.p_body_low = self.p_open elif self.p_open > self.p_close: self.c_white = False self.c_black = True self.r_body = n2d(self.p_open - self.p_close) self.r_upper_shadow = n2d(self.p_high - self.p_open) self.r_lower_shadow = n2d(self.p_close - self.p_low) self.p_body_high = self.p_open self.p_body_low = self.p_close else: self.c_white = False self.c_black = False self.r_body = n2d(self.p_open - self.p_close) self.r_upper_shadow = n2d(self.p_high - self.p_open) self.r_lower_shadow = n2d(self.p_close - self.p_low) self.p_body_high = self.p_open self.p_body_low = self.p_close