def calculate(self, look_back, wallet): """ Main strategy logic (the meat of the strategy) """ (dataset_cnt, _) = common.get_dataset_count(look_back, self.group_by_field) # Wait until we have enough data if dataset_cnt < self.min_history_ticks: print('dataset_cnt:', dataset_cnt) return self.actions self.actions.clear() new_action = TradeState.none # Calculate indicators df = look_back.tail(self.min_history_ticks) close = df['close'].values # ************** Calc EMA ema5 = talib.EMA(close[-5:], timeperiod=5)[-1] ema10 = talib.EMA(close[-10:], timeperiod=10)[-1] ema20 = talib.EMA(close[-20:], timeperiod=20)[-1] close_price = self.get_price(TradeState.none, df.tail(), self.pair) print(ema5) print(ema10) print('close_price:', str(close_price), 'ema:', str(ema20)) if close_price < ema10 or close_price < ema20: new_action = TradeState.sell elif close_price > ema5 and close_price > ema10: new_action = TradeState.buy # ************** Calc EMA Death Cross ema_interval_short = 6 ema_interval_long = 25 ema_short = talib.EMA(close[-ema_interval_short:], timeperiod=ema_interval_short)[-1] ema_long = talib.EMA(close[-ema_interval_long:], timeperiod=ema_interval_long)[-1] if ema_short <= ema_long: # If we are below death cross, sell new_action = TradeState.sell trade_price = self.get_price(new_action, df.tail(), self.pair) print("Trade price: {}".format(trade_price)) # Get stop-loss if new_action == TradeState.buy and self.stop_loss.calculate(close): print('stop-loss detected,..selling') new_action = TradeState.sell action = TradeAction(self.pair, new_action, amount=None, rate=trade_price, buy_sell_mode=self.buy_sell_mode) self.actions.append(action) return self.actions
def calculate(self, look_back, wallet): """ Main strategy logic (the meat of the strategy) """ (dataset_cnt, _) = common.get_dataset_count(look_back, self.group_by_field) # Wait until we have enough data if dataset_cnt < self.min_history_ticks: print('dataset_cnt:', dataset_cnt) return self.actions self.actions.clear() new_action = TradeState.none # Calculate indicators df = look_back.tail(self.min_history_ticks) close = df['close'].values last_row = df.tail(1).copy() # ************** Calc SMA-50 sma = df['close'].rolling(window=50).mean().values[-1] print('sma-50:', sma) # ************** Calc EMA-30 ema_period = 30 ema = df['close'].ewm(span=ema_period, adjust=False).mean().values[-1] print('ema-30:', ema) ema_above_sma = ema > sma print('ema_above_sma: ', ema_above_sma) if ema_above_sma: # self.buy_triggers += 1 # if self.buy_triggers >= 5: new_action = TradeState.buy else: new_action = TradeState.sell self.buy_triggers = 0 trade_price = self.get_price(new_action, df.tail(), self.pair) """ # Get stop-loss if new_action == TradeState.buy and self.stop_loss.calculate(close): print('stop-loss detected,..selling') new_action = TradeState.sell """ action = TradeAction(self.pair, new_action, amount=None, rate=trade_price, buy_sell_mode=self.buy_sell_mode) self.actions.append(action) return self.actions
def calculate(self, look_back, wallet): """ Main strategy logic (the meat of the strategy) """ (dataset_cnt, _) = common.get_dataset_count(look_back, self.group_by_field) # Wait until we have enough data if dataset_cnt < self.min_history_ticks: print('dataset_cnt:', dataset_cnt, ',..waiting for more data..') return self.actions self.actions.clear() df = look_back.tail(self.min_history_ticks) df_blueprint = Model.calculate_features(df) # Remove not-used columns df_blueprint = df_blueprint[self.feature_names] # Re-ordering column names column_names = self.feature_names x = df_blueprint[column_names] price_now = x.close.iloc[0] price_predicted = self.predict(x) if price_predicted is None: return self.actions else: price_predicted = price_predicted[0] if price_predicted > 0.08 or price_predicted < 0.05: return self.actions price_change = ((price_predicted * 100) / price_now) - 100 if price_change > 10: return self.actions self.trade_history = self.trade_history.append({'close': price_now, 'predicted': price_predicted}, ignore_index=True) self.trade_history.to_csv('out/luckyantelope_out.csv', index=False) print('price_change:' + str(price_change) + ', close_price: ' + str(x.close.iloc[0]) + ', predicted: ' + str(price_predicted)) new_action = TradeState.buy if price_predicted > price_now else TradeState.sell trade_price = self.get_price(new_action, df.tail(), self.pair) action = TradeAction(self.pair, new_action, amount=None, rate=trade_price, buy_sell_mode=self.buy_sell_mode) self.actions.append(action) return self.actions
def calculate(self, look_back, wallet): """ Main strategy logic (the meat of the strategy) """ (dataset_cnt, _) = common.get_dataset_count(look_back, self.group_by_field) # Wait until we have enough data if dataset_cnt < self.min_history_ticks: print('dataset_cnt:', dataset_cnt) return self.actions self.actions.clear() # Calculate indicators df = look_back.tail(self.min_history_ticks) close = df['close'].values # ************** Calc EMA20 ema20_period = 25 ema20 = talib.EMA(close[-ema20_period:], timeperiod=ema20_period)[-1] close_price = self.get_price(TradeState.none, df.tail(), self.pair) print('close_price:', close_price, 'ema:', ema20) if close_price <= ema20: new_action = TradeState.sell else: new_action = TradeState.buy # ************** Calc EMA Death Cross ema_interval_short = 6 ema_interval_long = 25 ema_short = talib.EMA(close[-ema_interval_short:], timeperiod=ema_interval_short)[-1] ema_long = talib.EMA(close[-ema_interval_long:], timeperiod=ema_interval_long)[-1] if ema_short <= ema_long: # If we are below death cross, sell new_action = TradeState.sell trade_price = self.get_price(new_action, df.tail(), self.pair) action = TradeAction(self.pair, new_action, amount=None, rate=trade_price, buy_sell_mode=self.buy_sell_mode) self.actions.append(action) return self.actions
def calculate(self, look_back, wallet): """ Main strategy logic (the meat of the strategy) """ (dataset_cnt, _) = common.get_dataset_count(look_back, self.group_by_field) # Wait until we have enough data if dataset_cnt < self.min_history_ticks: print('dataset_cnt:', dataset_cnt) return self.actions self.actions.clear() # Calculate indicators df = look_back.tail(self.min_history_ticks) close = df['close'].values volume = df['volume'].values new_action = TradeState.none close_price = self.get_price(TradeState.none, look_back, self.pair) # ************** OBV (On Balance Volume) obv = talib.OBV(close, volume)[-1] print('obv:', obv) if obv >= 100.0: new_action = TradeState.buy elif obv < 100.0: new_action = TradeState.sell # ************** Calc EMA ema_period = 6 ema = talib.EMA(close[-ema_period:], timeperiod=ema_period)[-1] if close_price <= ema: new_action = TradeState.sell if new_action == TradeState.none: return self.actions trade_price = self.get_price(new_action, df.tail(), self.pair) action = TradeAction(self.pair, new_action, amount=None, rate=trade_price, buy_sell_mode=self.buy_sell_mode) self.actions.append(action) return self.actions
def calculate(self, look_back, wallet): """ Main strategy logic (the meat of the strategy) """ (dataset_cnt, _) = common.get_dataset_count(look_back, self.group_by_field) # Wait until we have enough data if dataset_cnt < self.min_history_ticks: print('dataset_cnt:', dataset_cnt) return self.actions self.actions.clear() new_action = TradeState.none # Calculate indicators df = look_back.tail(self.min_history_ticks) close = df['close'] # ************** Calc EMA ema5 = ta.ema(close, length=5).values[-1] ema10 = ta.ema(close, length=10).values[-1] ema20 = ta.ema(close, length=20).values[-1] close_price = self.get_price(TradeState.none, df.tail(), self.pair) print('close_price:', close_price, 'ema:', ema20) if close_price < ema10 or close_price < ema20: new_action = TradeState.sell elif close_price > ema5 and close_price > ema10: new_action = TradeState.buy trade_price = self.get_price(new_action, df.tail(), self.pair) # Get stop-loss if new_action == TradeState.buy and self.stop_loss.calculate( close.values): print('stop-loss detected,..selling') new_action = TradeState.sell action = TradeAction(self.pair, new_action, amount=None, rate=trade_price, buy_sell_mode=self.buy_sell_mode) self.actions.append(action) return self.actions
def calculate(self, look_back, wallet): """ Main strategy logic (the meat of the strategy) """ (dataset_cnt, _) = common.get_dataset_count(look_back, self.group_by_field) # Wait until we have enough data if dataset_cnt < self.min_history_ticks: print('dataset_cnt:', dataset_cnt) return self.actions self.actions.clear() df = look_back.tail(self.min_history_ticks) df_blueprint = Model.calculate_features(df) # Remove not-used columns df_blueprint = df_blueprint.drop( ['pair', 'date', 'id', '_id', 'exchange', 'curr_1', 'curr_2'], axis=1) # Re-ordering column names column_names = self.feature_names x = df_blueprint[column_names] predicted = self.predict(x)[0] new_action = TradeState.sell if predicted == 1 else TradeState.buy trade_price = self.get_price(new_action, df.tail(), self.pair) action = TradeAction(self.pair, new_action, amount=None, rate=trade_price, buy_sell_mode=self.buy_sell_mode) self.actions.append(action) return self.actions
def calculate(self, look_back, wallet): """ Main Strategy function, which takes recent history data and returns recommended list of actions """ (dataset_cnt, pairs_count) = common.get_dataset_count(look_back, self.group_by_field) # Wait until we have enough data if dataset_cnt < self.min_history_ticks: print('dataset_cnt:', dataset_cnt) return self.actions self.actions.clear() look_back = look_back.tail(pairs_count * self.min_history_ticks) pairs_names = look_back.pair.unique() self.sync_active_pairs(wallet.current_balance) (current_weights, wallet_value) = self.compute_weights_and_value(look_back, wallet) current_amounts = list(wallet.current_balance.values()) currencies = list(wallet.current_balance.keys()) look_back.reset_index() # converted_look_back = look_back.pivot(index=['date', 'pair'], columns='pair', values='close') converted_look_back = look_back.pivot_table(index='date', columns='pair', values='close') converted_look_back['BTC_BTC'] = 1 converted_look_back = converted_look_back.filter( items=self.compute_relevant_pairs(wallet, 'BTC')) converted_look_back = converted_look_back.tail(self.min_history_ticks) if self.first_values.empty: self.first_values = converted_look_back.iloc[0] self.algo.init_step(converted_look_back) next_weights = self.my_next_weights(converted_look_back, current_weights) # next_weights = (current_weights + next_weights) / 2 # next_weights = self.algo.next_weights(converted_look_back, current_weights) # We sell first, then we buy # if new_weight < current_weight, we need to sell the related currency for i in range(0, len(currencies)): if (next_weights[i] < current_weights[i] and currencies[i] != 'BTC' and current_amounts[i] > 0): # no need to sell BTC close_pair_price = self.get_price(TradeState.sell, look_back, 'BTC_' + currencies[i]) action = TradeAction('BTC_' + currencies[i], TradeState.sell, amount=current_amounts[i] * (current_weights[i] - next_weights[i]) / current_weights[i], rate=close_pair_price, buy_sell_mode=self.buy_sell_mode) self.actions.append(action) # if new_weight > current_weight, we need to buy the related currency for i in range(0, len(currencies)): if (next_weights[i] > current_weights[i] and currencies[i] != 'BTC' and next_weights[i] != 0): close_pair_price = self.get_price(TradeState.sell, look_back, 'BTC_' + currencies[i]) action = TradeAction( 'BTC_' + currencies[i], TradeState.buy, # let's only buy 99% of what the algo recommands to avoid going negative with the fees amount=0.99 * (wallet_value / close_pair_price) * (next_weights[i] - current_weights[i]), rate=close_pair_price, buy_sell_mode=self.buy_sell_mode) self.actions.append(action) return self.actions
def calculate(self, look_back, wallet, tickr): """ Main strategy logic (the meat of the strategy) """ (dataset_cnt, _) = common.get_dataset_count(look_back, self.group_by_field) # Wait until we have enough data if dataset_cnt < self.min_history_ticks: print('dataset_cnt:', dataset_cnt) return self.actions self.actions.clear() new_action = TradeState.none # Calculate indicators df = look_back.tail(self.min_history_ticks) close = df['close'].values df1 = df['id'].tail(n=1) val = df1.iloc[0] val = val.split('-') loop_time = int(val[2]) market_pair = 'BTCUSD' sentiment = 'Bear' timeframe = '4h' indicator_type = 'Bear TCG Cross' loop_datetime = datetime.fromtimestamp( loop_time, tz=pytz.utc).strftime('%Y-%m-%d %H:%M:%S') alerts = self.data.load_backtest_epochs(market_pair, sentiment, timeframe, indicator_type, loop_datetime) for alert_time in alerts['epochs']: if alert_time in range(loop_time - 1800, loop_time): print( "+!+!+!+!+!++!+!+!+!++!+!++!+! ALERT HIT +!+!+!+!++!+!+! {} {} {} " .format(alert_time, loop_time - 1800, loop_time)) print(datetime.fromtimestamp(alert_time).strftime('%c')) print(datetime.fromtimestamp(loop_time - 1800).strftime('%c')) print(datetime.fromtimestamp(loop_time).strftime('%c')) new_action = TradeState.sell trade_price = self.get_price(new_action, df.tail(), self.pair) # print("trade price {}".format(trade_price) # Get stop-loss if new_action == TradeState.sell and self.stop_loss.calculate(close): print( '-------- stop-loss detected,..buying!!!!!!!!!!!!!!!!!!!!!!!! ' ) new_action = TradeState.buy action = TradeAction(self.pair, new_action, amount=None, rate=trade_price, buy_sell_mode=self.buy_sell_mode) self.actions.append(action) return self.actions
def calculate(self, look_back, wallet): """ Main strategy logic (the meat of the strategy) """ (dataset_cnt, _) = common.get_dataset_count(look_back, self.group_by_field) # Wait until we have enough data if dataset_cnt < self.min_history_ticks: print('dataset_cnt:', dataset_cnt) return self.actions self.actions.clear() new_action = TradeState.none # Calculate indicators df = look_back.tail(self.min_history_ticks) self.chartData_ = df for i in df[['close']]: for j in df[i]: last_price = round(j, 10) Points.append(last_price) for i in df[['high']]: for j in df[i]: Highs.append(round(j, 8)) for i in df[['low']]: for j in df[i]: Lows.append(round(j, 8)) for i in df[['volume']]: for j in df[i]: Volumes.append(round(j, 8)) for i in df[['date']]: for j in df[i]: last_time = dt.datetime.fromtimestamp(j) dates.append(last_time) self.appreciationRate_ = self.getAppreciationRate(self.chartData_.open) self.quantizer_ = self.quantizer(self.appreciationRate_) print("Format appreciation {}".format(self.appreciationRate_)) print("Format quantizer {}".format(self.quantizer_)) #self.prediction(self.appreciationRate_, self.quantizer_, 0, 30, 30) #bactTest_ = self.backTest(self.appreciationRate_, self.quantizer_, 30, 15, False) #print(bactTest_) fed_data = feature_engineering(df) # feature vector X = fed_data.take(list(range(fed_data.shape[1] - 1)), axis=1) # target y = np.ravel(fed_data.take([fed_data.shape[1] - 1], axis=1)) X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=0) print(X_train.shape, y_train.shape, X_test.shape, y_test.shape) # 定义一个BP神经网络 reg = MLPRegressor(solver='lbfgs', alpha=1e-5, hidden_layer_sizes=(15, ), random_state=1) # 训练 print("start training...") reg.fit(X_train, y_train) print("training finished.") # 预测 print("start predicting...") y_pred = reg.predict(X_test) print("predicting finished.") y_pred = pd.DataFrame(y_pred) y_pred.index = X_test.index y_test = pd.DataFrame(y_test) y_test.index = X_test.index # 将结果写入文件 # pd.DataFrame(y_pred).to_excel('y_pred.xlsx') # 模型评估 model_evaluation(y_test, y_pred) # 可视化 model_visualization(y_test, y_pred) print(type(X), type(y), type(X_train), type(X_test), type(y_train), type(y_test), type(y_pred)) days = len(df[['close']]) print("Last time: " + str(last_time) + " " + str(last_price)) if days > acc: decision = algot(Points[:days]) new_last_time = last_time + dt.timedelta(minutes=self.interval) print( '-----------------------------------------------------------------------------------------' ) print( '| |' ) print( '| |' ) print( '| |' ) #if self.Bought == True: if decision == 0: self.Bought = False print( colored( "* Buy now or wait, price will went UP at {} *" .format(new_last_time), 'green')) #new_action = TradeState.sell #else: elif decision == 1: self.Bought = True #new_action = TradeState.buy print( colored( "* Sell now or wait, price will went DOWN at {} *" .format(new_last_time), 'red')) print( '| |' ) print( '| |' ) print( '| |' ) print( '-----------------------------------------------------------------------------------------' ) trade_price = self.get_price(new_action, df.tail(), self.pair) # Get stop-loss #if new_action == TradeState.buy and self.stop_loss.calculate(close): # print('stop-loss detected,..selling') # new_action = TradeState.sell action = TradeAction(self.pair, new_action, amount=None, rate=trade_price, buy_sell_mode=self.buy_sell_mode) self.actions.append(action) return self.actions
def calculate(self, look_back, wallet): """ Main Strategy function, which takes recent history data and returns recommended list of actions """ (current_weights, wallet_value) = self.compute_weights_and_value(look_back, wallet) print("Current weights:", current_weights) (dataset_cnt, pairs_count) = common.get_dataset_count(look_back, self.group_by_field) look_back = look_back.tail(pairs_count * self.min_history_ticks) pairs_names = look_back.pair.unique() look_back.reset_index() if not self.DRL: self.DRL = PolicyGradient( n_actions=pairs_count, n_features=3, #6*self.min_history_ticks output_graph=True, ) if self.last_computed_weights != []: self.step += 1 future_prices = self.compute_future_prices(look_back) weights = np.array(self.last_20_measured_weights).transpose( (1, 2, 0)) self.DRL.store_transition( self.last_prices, weights, #np.array(self.last_20_measured_weights).reshape((pairs_count,1,20)), future_prices, np.array(current_weights).reshape((pairs_count + 1, 1, 1))) if (len(self.last_20_measured_weights) >= 20): self.last_20_measured_weights.pop() self.last_20_measured_weights.insert( 0, current_weights[1:].reshape((pairs_count, 1))) # Wait until we have enough data if dataset_cnt < self.min_history_ticks: print('dataset_cnt:', dataset_cnt) return self.actions self.actions.clear() current_amounts = list(wallet.current_balance.values()) self.DRL.learn() currencies = list(wallet.current_balance.keys()) # converted_look_back = look_back.pivot(index=['date', 'pair'], columns='pair', values='close') # converted_look_back = look_back.pivot_table(index='date', columns='pair', values='close') close = look_back.pivot_table(index='pair', columns='date', values='close') last_column = close.iloc[:, -1] close = close.div(last_column, axis='index') high = look_back.pivot_table(index='pair', columns='date', values='high') high = high.div(last_column, axis='index') low = look_back.pivot_table(index='pair', columns='date', values='low') low = low.div(last_column, axis='index') features = np.array( [close.as_matrix(), high.as_matrix(), low.as_matrix()]) features = features[np.newaxis, :] # assert(features.shape == (1,3,pairs_count,50)) # converted_look_back = converted_look_back.filter(items = self.compute_relevant_pairs(wallet, 'BTC')) # converted_look_back = converted_look_back.tail(self.min_history_ticks) # next_weights = self.DRL.choose_weights(converted_look_back) next_weights = self.DRL.choose_weights(features, self.last_20_measured_weights) print("New weights:", next_weights) # assert( (next_weights[0] != next_weights[1]) and (next_weights[1] != next_weights[2]) ) self.last_computed_weights = next_weights[np.newaxis, :] self.last_prices = features # let's estimate mu mu, _ = self.DRL.compute_mu(next_weights, current_weights, self.commission) # We sell first, then we buy # if new_weight < current_weight, we need to sell the related currency for i in range(0, len(currencies)): if (next_weights[i] < current_weights[i] and currencies[i] != 'BTC' and current_amounts[i] > 0): # no need to sell BTC close_pair_price = self.get_price(TradeState.sell, look_back, 'BTC_' + currencies[i]) action = TradeAction('BTC_' + currencies[i], TradeState.sell, amount=current_amounts[i] * (current_weights[i] - next_weights[i]) / (current_weights[i] * mu), rate=close_pair_price, buy_sell_mode=self.buy_sell_mode) self.actions.append(action) # if new_weight > current_weight, we need to buy the related currency for i in range(0, len(currencies)): if (next_weights[i] > current_weights[i] and currencies[i] != 'BTC' and next_weights[i] != 0): close_pair_price = self.get_price(TradeState.sell, look_back, 'BTC_' + currencies[i]) action = TradeAction( 'BTC_' + currencies[i], TradeState.buy, # let's only buy 99% of what the algo recommands to avoid going negative with the fees amount=mu * (wallet_value / close_pair_price) * (next_weights[i] - current_weights[i]), rate=close_pair_price, buy_sell_mode=self.buy_sell_mode) self.actions.append(action) return self.actions
def calculate(self, look_back, wallet): """ Main strategy logic (the meat of the strategy) """ (dataset_cnt, _) = common.get_dataset_count(look_back, self.group_by_field) # Wait until we have enough data if dataset_cnt < self.min_history_ticks: print('dataset_cnt:', dataset_cnt) return self.actions self.actions.clear() new_action = TradeState.none # Calculate indicators df = look_back.tail(self.min_history_ticks) for i in df[['close']]: for j in df[i]: last_price = round(j, 10) Points.append(last_price) for i in df[['high']]: for j in df[i]: Highs.append(round(j, 8)) for i in df[['low']]: for j in df[i]: Lows.append(round(j, 8)) for i in df[['volume']]: for j in df[i]: Volumes.append(round(j, 8)) for i in df[['date']]: for j in df[i]: last_time = dt.datetime.fromtimestamp(j) dates.append(last_time) days = len(df[['close']]) print("Last time: " + str(last_time) + " " + str(last_price)) if days > acc: decision = algot(Points[:days]) new_last_time = last_time + dt.timedelta(minutes=self.interval) print( '-----------------------------------------------------------------------------------------' ) print( '| |' ) print( '| |' ) print( '| |' ) #if self.Bought == True: if decision == 0: self.Bought = False print( colored( "* Buy now or wait, price will went UP at {} *" .format(new_last_time), 'green')) #new_action = TradeState.sell #else: elif decision == 1: self.Bought = True #new_action = TradeState.buy print( colored( "* Sell now or wait, price will went DOWN at {} *" .format(new_last_time), 'red')) print( '| |' ) print( '| |' ) print( '| |' ) print( '-----------------------------------------------------------------------------------------' ) trade_price = self.get_price(new_action, df.tail(), self.pair) # Get stop-loss #if new_action == TradeState.buy and self.stop_loss.calculate(close): # print('stop-loss detected,..selling') # new_action = TradeState.sell action = TradeAction(self.pair, new_action, amount=None, rate=trade_price, buy_sell_mode=self.buy_sell_mode) self.actions.append(action) return self.actions
def calculate(self, look_back, wallet): """ Main Strategy function, which takes recent history data and returns recommended list of actions """ if not self.pair_delimiter: self.pair_delimiter = self.get_delimiter(look_back) (dataset_cnt, pairs_count) = common.get_dataset_count(look_back, self.group_by_field) # Wait until we have enough data if dataset_cnt < self.min_history_ticks: print('dataset_cnt:', dataset_cnt) return self.actions self.actions.clear() look_back = look_back.tail(pairs_count * self.min_history_ticks) pairs_names = look_back.pair.unique() self.sync_active_pairs(wallet.current_balance) positive_pairs = [] got_all_buffers = True for pair in pairs_names: df = look_back.loc[look_back['pair'] == pair].sort_values('date') # Check if the dataset has required buffer size df_size = len(df.index) if df_size < self.min_history_ticks: continue close = df['close'].values # volume = df['volume'].values close_price = self.get_price(TradeState.none, look_back, pair) # ************** Calc EMA20 ema20_period = 20 ema20 = talib.EMA(close[-ema20_period:], timeperiod=ema20_period)[-1] if close_price <= ema20: continue # ************** Calc RSI rsi = talib.RSI(close[-15:], timeperiod=14)[-1] if rsi > 20: continue # ************** Calc EMA ema_interval_short = 6 ema_interval_long = 25 ema_short = talib.EMA(close[-ema_interval_short:], timeperiod=ema_interval_short)[-1] ema_long = talib.EMA(close[-ema_interval_long:], timeperiod=ema_interval_long)[-1] if ema_short <= ema_long: # If we are below death cross, skip pair continue positive_pairs.append((pair, 0.0)) # If we didn't get all buffers just return empty actions if not got_all_buffers: return self.actions # Handle all the pairs that have not been selected (are not up-trending) positive_pair_names = [ re.split('[-_]', i[0])[-1] for i in positive_pairs ] pair_prefix = re.split('[-_]', pairs_names[0])[0] for wallet_item in wallet.current_balance: if wallet_item == pair_prefix: continue if wallet_item not in positive_pair_names: pair_name = pair_prefix + self.pair_delimiter + wallet_item close_pair_price = self.get_price(TradeState.sell, look_back, pair_name) action = TradeAction(pair_name, TradeState.sell, amount=None, rate=close_pair_price, buy_sell_mode=self.buy_sell_mode) self.actions.append(action) if pair_name in self.active_pairs: self.active_pairs.remove(pair_name) # Handle positive pairs # Sort indicators sorted_positives = sorted(positive_pairs, key=lambda x: x[1], reverse=True) print('sorted_indicators:', len(sorted_positives), 'items:', sorted_positives) # Take only first 3 pairs # if len(sorted_positives) > 3: # sorted_positives = sorted_positives[:3] for (positive_pair, _) in sorted_positives: # Check if we have already bought the currency. If yes, just skip it if positive_pair in self.active_pairs: continue # If pair is not bought yet, buy it close_pair_price = self.get_price(TradeState.buy, look_back, positive_pair) action = TradeAction(positive_pair, TradeState.buy, amount=None, rate=close_pair_price, buy_sell_mode=self.buy_sell_mode) self.active_pairs.append(positive_pair) self.actions.append(action) return self.actions