def vfi(dataframe, length=130, coef=0.2, vcoef=2.5, signalLength=5, smoothVFI=False): """ Volume Flow Indicator conversion Author: creslinux, June 2018 - Python Original Author: Chris Moody, TradingView - Pinescript To return vfi, vfima and histogram A simplified interpretation of the VFI is: * Values above zero indicate a bullish state and the crossing of the zero line is the trigger or buy signal. * The strongest signal with all money flow indicators is of course divergence. * A crossover of vfi > vfima is uptrend * A crossunder of vfima > vfi is downtrend * smoothVFI can be set to smooth for a cleaner plot to ease false signals * histogram can be used against self -1 to check if upward or downward momentum Call from strategy to populate vfi, vfima, vfi_hist into dataframe Example how to call: # Volume Flow Index: Add VFI, VFIMA, Histogram to DF dataframe['vfi'], dataframe['vfima'], dataframe['vfi_hist'] = \ vfi(dataframe, length=130, coef=0.2, vcoef=2.5, signalLength=5, smoothVFI=False) :param dataframe: :param length: - VFI Length - 130 default :param coef: - price coef - 0.2 default :param vcoef: - volume coef - 2.5 default :param signalLength: - 5 default :param smoothVFI: bool - False detault :return: vfi, vfima, vfi_hist """ """" Original Pinescript From: https://www.tradingview.com/script/MhlDpfdS-Volume-Flow-Indicator-LazyBear/ length = input(130, title="VFI length") coef = input(0.2) vcoef = input(2.5, title="Max. vol. cutoff") signalLength=input(5) smoothVFI=input(false, type=bool) #### Conversion summary to python - ma(x,y) => smoothVFI ? sma(x,y) : x // Added as smoothVFI test on vfi - typical = hlc3 // Added to DF as HLC - inter = log(typical) - log(typical[1]) // Added to DF as inter - vinter = stdev(inter, 30) // Added to DF as vinter - cutoff = coef * vinter * close // Added to DF as cutoff - vave = sma(volume, length)[1] // Added to DF as vave - vmax = vave * vcoef // Added to Df as vmax - vc = iff(volume < vmax, volume, vmax) // Added np.where test, result in DF as vc - mf = typical - typical[1] // Added into DF as mf - typical is hlc3 - vcp = iff(mf > cutoff, vc, iff(mf < -cutoff, -vc, 0)) // added in def vcp, in DF as vcp - vfi = ma(sum(vcp, length) / vave, 3) // Added as DF vfi. Will sma vfi 3 if smoothVFI flag set - vfima = ema(vfi, signalLength) // added to DF as vfima - d = vfi-vfima // Added to df as histogram ### Pinscript plotout - nothing to do here for freqtrade. plot(0, color=gray, style=3) showHisto=input(false, type=bool) plot(showHisto ? d : na, style=histogram, color=gray, linewidth=3, transp=50) plot( vfima , title="EMA of vfi", color=orange) plot( vfi, title="vfi", color=green,linewidth=2) """ import talib as ta from math import log from pyti.simple_moving_average import simple_moving_average as sma from numpy import where length = length coef = coef vcoef = vcoef signalLength = signalLength smoothVFI = smoothVFI df = dataframe # Add hlc3 and populate inter to the dataframe df['hlc'] = ((df['high'] + df['low'] + df['close']) / 3).astype(float) df['inter'] = df['hlc'].map(log) - df['hlc'].shift(+1).map(log) df['vinter'] = df['inter'].rolling(30).std(ddof=0) df['cutoff'] = (coef * df['vinter'] * df['close']) # Vave is to be calculated on volume of the past bar df['vave'] = sma(df['volume'].shift(+1), length) df['vmax'] = df['vave'] * vcoef df['vc'] = where((df['volume'] < df['vmax']), df['volume'], df['vmax']) df['mf'] = df['hlc'] - df['hlc'].shift(+1) # more logic for vcp, so create a def and df.apply it def vcp(x): if x['mf'] > x['cutoff']: return x['vc'] elif x['mf'] < -(x['cutoff']): return -(x['vc']) else: return 0 df['vcp'] = df.apply(vcp, axis=1) # vfi has a smooth option passed over def call, sma if set df['vfi'] = (df['vcp'].rolling(length).sum()) / df['vave'] if smoothVFI == True: df['vfi'] = sma(df['vfi'], 3) df['vfima'] = ta.EMA(df['vfi'], signalLength) df['vfi_hist'] = df['vfi'] - df['vfima'] # clean up columns used vfi calculation but not needed for strat df.drop('hlc', axis=1, inplace=True) df.drop('inter', axis=1, inplace=True) df.drop('vinter', axis=1, inplace=True) df.drop('cutoff', axis=1, inplace=True) df.drop('vave', axis=1, inplace=True) df.drop('vmax', axis=1, inplace=True) df.drop('vc', axis=1, inplace=True) df.drop('mf', axis=1, inplace=True) df.drop('vcp', axis=1, inplace=True) return df['vfi'], df['vfima'], df['vfi_hist']
def loop(self): timeout = 3 / float(len(self.products)) counter = 0 by_volume = [] # array of dicts # TODO: for coins that are in the balance, sell once order book is tending towards selling side # maybe also last 10 trades could be checked and if most are sell, then sell as well. # TODO: move checker for coins in balance into a separate, faster loop. while self._running: self._balances = self.get_balance() # refresh balance product = self.products[counter] ticker_symbol = product['symbol'] if ticker_symbol.endswith('BTC'): idx = ticker_symbol.index('BTC') elif ticker_symbol.endswith('USDT'): idx = ticker_symbol.index('USDT') coin1 = ticker_symbol[:idx] coin2 = ticker_symbol[idx:] if self.is_coin_blacklisted(coin1): logging.info("{}: blacklisted, skipping.".format(coin1)) else: #logging.info("Check {}...".format(ticker_symbol)) try: # get klines since close new_klines = self.client.get_klines( symbol=ticker_symbol, interval='5m', startTime=self._klines[ticker_symbol][-1][0]) new_klines2 = self.client.get_klines( symbol=ticker_symbol, interval='1h', startTime=self._klines2[ticker_symbol][-1][0]) for kline_group in [{ 'new': new_klines, 'old': self._klines }, { 'new': new_klines2, 'old': self._klines2 }]: for kline in kline_group['new']: if kline[0] != kline_group['old'][ticker_symbol][ -1][0]: kline_group['old'][ticker_symbol].append(kline) else: kline_group['old'][ticker_symbol][-1] = kline if len(kline_group['old'] [ticker_symbol]) > self._start_size: kline_group['old'][ticker_symbol].pop(0) # short term volumes = list( map(lambda item: float(item[5]), self._klines[ticker_symbol][-30:])) volumes_sorted = sorted(volumes) median_volume = 0 mean_volume = reduce(lambda x, y: x + y, volumes_sorted) / len(volumes_sorted) if len(volumes_sorted) % 2 != 0: mid = len(volumes_sorted) / 2 f = floor(mid) c = ceil(mid) assert f < c, "floor should be less than ceiling ({} vs {})".format( f, c) median_volume = (volumes_sorted[f] + volumes_sorted[c]) / 2 else: median_volume = volumes_sorted[len(volumes_sorted) // 2] # divide median by mean med_mean = median_volume / mean_volume last_volume = volumes[-1] last_volume_mean = last_volume / mean_volume ticker_data = self.client.get_ticker(symbol=ticker_symbol) volume_btc = float(ticker_data['volume']) * float( ticker_data['lastPrice']) if float(self._klines[ticker_symbol][-2][1]) <= float( self._klines[ticker_symbol][-2][4]): if (coin1 not in self._balances or self._balances[coin1] == 0) and (coin2 in self._balances and self._balances[coin2] > 0): price_closes = list( map(lambda item: float(item[4]), self._klines[ticker_symbol])) sma7 = sma(price_closes, 7) sma20 = sma(price_closes, 20) logging.info("{}: SMA7: {}, SMA20: {}".format( ticker_symbol, sma7[-1], sma20[-1])) depth = self.client.get_order_book( symbol=ticker_symbol, limit=10) bid_sum = reduce( lambda x, y: x + y, list( map(lambda item: float(item[1]), depth['bids']))) ask_sum = reduce( lambda x, y: x + y, list( map(lambda item: float(item[1]), depth['asks']))) logging.info("{} bid sum: {}, ask sum: {}".format( ticker_symbol, bid_sum, ask_sum)) if (volume_btc > 200) and ( last_volume_mean / med_mean > 2) and (price_closes[-1] > sma7[-1]) and ( sma7[-1] > sma20[-1]): price_closes_lt = list( map(lambda kline: float(kline[4]), self._klines2[ticker_symbol])) stoch_rsi_results = stochrsi( price_closes_lt, 14) logging.info("{} SRSI : {}".format( ticker_symbol, stoch_rsi_results[-1])) if stoch_rsi_results[-1] >= 60: logging.info( "skip {}, already pumped".format( ticker_symbol)) elif bid_sum < ask_sum: logging.info( "Not buying {} because bid sum ({}) < ask sum ({})" .format(ticker_symbol, bid_sum, ask_sum)) else: self.buy(symbol=ticker_symbol, coin1=coin1, coin2=coin2) self.blacklist_coin( best_coin['coin1'], THIRTY_MINUTES) # by_volume.append({ # 'symbol': ticker_symbol, # 'coin1': coin1, # 'coin2': coin2, # 'value': last_volume_mean / med_mean, # 'sma7': sma7 # }) # if last_volume_mean / med_mean > 2: # logging.info("\n\n!! {} Abnormal volume = {} / {}\n\n".format(ticker_symbol, last_volume_mean, med_mean)) # if float(self._klines[ticker_symbol][-2][1]) > float(self._klines[ticker_symbol][-2][4]): # logging.info("{} is likely falling (red candle), not buying.".format(ticker_symbol)) # else: # self.buy(ticker_symbol, coin1, coin2) coin_amount_held = 0 coin_is_dust = True trailing_stop_triggered = False if coin1 in self._balances: coin_amount_held = self._balances[coin1] coin_price = float(self._klines[ticker_symbol][-1][4]) if coin2 == 'BTC': if coin_price * coin_amount_held >= 0.0005: # lt ~$5 worth of bitcoin coin_is_dust = False elif coin2 == 'USDT': if coin_price * coin_amount_held >= 5: # lt ~$5 coin_is_dust = False else: raise Exception( "Unsure how to handle coin2 type: {}".format( coin2)) if coin_is_dust: self._balances[coin1] = 0 # just set to zero else: if ticker_symbol in self._trailing_stops: if coin_price <= self._trailing_stops[ ticker_symbol]: logging.info( "{}: Trailing stop triggered @ {}".format( ticker_symbol, coin_price)) self.sell(ticker_symbol, coin1, coin2) self.blacklist_coin(coin1, TWO_HOURS) trailing_stop_triggered = True else: self.update_trailing_stop_for(ticker_symbol) except Exception as ex: logging.error("Error: {}".format(ex)) counter += 1 counter %= len(self.products) if False and counter == 0: by_volume_sorted = sorted(by_volume, key=lambda item: item['value']) best_coin = None for i in range(len(by_volume_sorted) - 1, -1, -1): item = by_volume_sorted[i] last_sma7 = item['sma7'][-1] # find a recent candle with most volume, determine red or green last_klines = self._klines[item['symbol']][-4:] last_kline = self._klines[item['symbol']][-1] top_kline = None for kline in last_klines: if top_kline is None or (float(kline[5]) > float( top_kline[5])): top_kline = kline assert top_kline is not None logging.info("{} top_kline = {}".format( item['symbol'], top_kline)) # determine red or green if float(top_kline[1]) > float(top_kline[4]) or float( last_kline[1]) > float(last_kline[4]): logging.info( "skip {} because dump determined ({} > {})".format( item['symbol'], top_kline[1], top_kline[4])) else: price_closes = list( map(lambda kline: float(kline[4]), self._klines[item['symbol']])) stoch_rsi_results = stochrsi(price_closes, 14) logging.info("{} SRSI : {}".format( item['symbol'], stoch_rsi_results[-1])) if stoch_rsi_results[-1] >= 60: logging.info("skip {}, already pumped".format( item['symbol'])) else: if float(last_klines[-2][4]) > last_sma7: best_coin = item break else: logging.info("{} is below sma ({}, {})".format( item['symbol'], last_sma7, last_klines[-2][4])) assert best_coin is not None logging.info("by_volume_sorted = {}".format(by_volume_sorted)) #logging.info("\nbest_coin = {}\n".format(best_coin)) self.buy(symbol=best_coin['symbol'], coin1=best_coin['coin1'], coin2=best_coin['coin2']) self.blacklist_coin(best_coin['coin1'], THIRTY_MINUTES) by_volume = [] time.sleep(timeout)
while cn < 100: close = get_historic_klines(symbol, "2 days ago UTC", "now UTC", Client.KLINE_INTERVAL_5MINUTE) ochl = get_historic_klines_ochl(symbol, "2 days ago UTC", "now UTC", Client.KLINE_INTERVAL_5MINUTE) source = close data.append(source[-1]) fastLength = 12 slowLength = 26 # take from binance signalLength = 9 fastMA = ema(source, fastLength) slowMA = ema(source, slowLength) macd = fastMA - slowMA signal = sma(macd, signalLength) hist = macd - signal stochastic_data = get_historic_klines_stochastic( symbol, "20 days ago UTC", "now UTC", Client.KLINE_INTERVAL_1DAY) stochastic_li = stochastic_data['%K'].tolist() decision(hist, stochastic_li, data, inventory) cn += 1 #decision(macdo,signalo) """ final = histo.join(macdo, lsuffix='_left', rsuffix='_right') final = final.join(signalo, lsuffix='_left', rsuffix='_right') fig, (ax1, ax2, ax3) = plt.subplots(3, figsize=(20, 20))
def Update(self): self.logMessages = self.logMessages + "\n" + ( str(dt.datetime.now()) + " " + self.timeframe + " Vela Formada - Analizando - Running Update Function...") self.pricedata_stadistics['index'] = self.pricedata['bidclose'].index self.pricedata_stadistics['bidclose'] = self.pricedata[ 'bidclose'].values self.pricedata_stadistics['bidhigh'] = self.pricedata['bidhigh'].values self.pricedata_stadistics['askclose'] = self.pricedata[ 'askclose'].values self.pricedata_stadistics['askhigh'] = self.pricedata['askhigh'].values self.pricedata_stadistics['asklow'] = self.pricedata['asklow'].values self.pricedata_stadistics['askclose'] = self.pricedata[ 'askclose'].values self.pricedata_stadistics['bidlow'] = self.pricedata['bidlow'].values self.pricedata_stadistics['tickqty'] = self.pricedata['tickqty'].values # Calculate Indicators iFastSMA = sma(self.pricedata['bidclose'], self.fast_sma_periods) iSlowSMA = sma(self.pricedata['bidclose'], self.slow_sma_periods) self.pricedata_stadistics['emaFast'] = iFastSMA self.pricedata_stadistics['emaSlow'] = iSlowSMA # Adds a "n_high" column with max value of previous 14 periods self.pricedata_stadistics['n_high'] = self.pricedata_stadistics[ 'bidhigh'].rolling(self.stoK).max() # Adds an "n_low" column with min value of previous 14 periods self.pricedata_stadistics['n_low'] = self.pricedata_stadistics[ 'bidlow'].rolling(self.stoK).min() # Uses the min/max values to calculate the %k (as a percentage) self.pricedata_stadistics['per_k'] = \ ( (self.pricedata_stadistics['bidclose'] - self.pricedata_stadistics['n_low']) / \ (self.pricedata_stadistics['n_high'] - self.pricedata_stadistics['n_low']) ) * 100 # Uses the %k to calculates a SMA over the past 3 values of %k self.pricedata_stadistics['per_d'] = self.pricedata_stadistics[ 'per_k'].rolling(self.stoD).mean() # data_per_k = per_k(pricedata['bidclose'], stoK) # data_per_d = per_d(pricedata['bidclose'], stoD) data_per_k = self.pricedata_stadistics['per_k'] data_per_d = self.pricedata_stadistics['per_d'] # pricedata_stadistics['per_k'] = data_per_k # pricedata_stadistics['per_d'] = data_per_d # self.pricedata_stadistics.loc[index, 'lower_sto'] = 20 # self.pricedata_stadistics.loc[index, 'upper_sto'] = 80 self.logMessages = self.logMessages + "\n" + ( "STO K " + str(data_per_k[len(data_per_k) - 1])) self.logMessages = self.logMessages + "\n" + ( "STO D " + str(data_per_d[len(data_per_d) - 1])) # Calcular Indicador iRSI = rsi(self.pricedata_stadistics['bidclose'], 15) self.logMessages = self.logMessages + "\n" + ("RSI: " + str(iRSI[len(iRSI) - 1])) for index, row in self.pricedata_stadistics.iterrows(): self.pricedata_stadistics.loc[index, 'lower_sto'] = 20 self.pricedata_stadistics.loc[index, 'upper_sto'] = 80 self.pricedata_stadistics.loc[index, 'macdline0'] = 0.00 self.pricedata_stadistics.loc[index, 'macdsub'] = self.macdsub self.pricedata_stadistics.loc[index, 'macdupper'] = self.macduper # *********************************************************** # * Regresion al precio de cierre las velas ================ # *********************************************************** self.pricedata_stadistics['x'] = np.arange( len(self.pricedata_stadistics)) # ************* Calcular la poscion Relativa Y for index, row in self.pricedata_stadistics.iterrows(): self.pricedata_stadistics.loc[index, 'y'] = int('{:.5f}'.format( (self.pricedata_stadistics.loc[index, 'bidclose'])).replace('.', '')) max_value = max(np.array(self.pricedata_stadistics['y'].values)) min_value = min(np.array(self.pricedata_stadistics['y'].values)) for index, row in self.pricedata_stadistics.iterrows(): value = self.pricedata_stadistics.loc[index, 'y'] - min_value NewPricePosition = ((value * 100) / max_value) * 100 self.pricedata_stadistics.loc[index, 'y'] = NewPricePosition # *********** Calcular la poscion Relativa X max_value = max(np.array(self.pricedata_stadistics['x'].values)) min_value = min(np.array(self.pricedata_stadistics['x'].values)) for index, row in self.pricedata_stadistics.iterrows(): value = self.pricedata_stadistics.loc[index, 'x'] - min_value NewPricePosition = ((value * 100) / max_value) self.pricedata_stadistics.loc[index, 'x'] = NewPricePosition regresionLineal_xx = np.array(self.pricedata_stadistics['x'].values) regresionLineal_yy = np.array(self.pricedata_stadistics['y'].values) regresionLineal_bb = regresionlineal2.estimate_b0_b1( regresionLineal_xx, regresionLineal_yy) y_pred_sup = regresionLineal_bb[ 0] + regresionLineal_bb[1] * regresionLineal_xx self.pricedata_stadistics['y_pred'] = y_pred_sup if self.pricedata_stadistics.iloc[len(self.pricedata_stadistics) - 1]['y_pred'] < \ self.pricedata_stadistics.iloc[1]['y_pred'] and \ self.pricedata_stadistics.iloc[len(self.pricedata_stadistics) - 1]['y_pred'] < \ self.pricedata_stadistics.iloc[1]['y_pred']: lv_Tendency = "Bajista" elif self.pricedata_stadistics.iloc[len(self.pricedata_stadistics) - 1]['y_pred'] > \ self.pricedata_stadistics.iloc[1]['y_pred'] and \ self.pricedata_stadistics.iloc[len(self.pricedata_stadistics) - 1]['y_pred'] > \ self.pricedata_stadistics.iloc[1]['y_pred']: lv_Tendency = "Alcista" # MACD ######################################################################## exp1 = self.pricedata_stadistics['bidclose'].ewm(span=self.macdFast, adjust=False).mean() exp2 = self.pricedata_stadistics['bidclose'].ewm(span=self.macdSlow, adjust=False).mean() macd = exp1 - exp2 self.pricedata_stadistics[ 'macd'] = self.pricedata_stadistics.index.map(macd) self.pricedata_stadistics['signal'] = pd.DataFrame( self.pricedata_stadistics['macd'].ewm(span=self.macdSmooth, adjust=False).mean()) self.pricedata_stadistics['hist'] = pd.DataFrame( self.pricedata_stadistics['macd'] - self.pricedata_stadistics['signal']) # Imprimir Precio/Indicador # self.logMessages = self.logMessages + "\n" + ("Precio Cierre: " + str(pricedata['bidclose'][len(pricedata) - 1])) # self.logMessages = self.logMessages + "\n" + ("Tendencia Regresion Lineal: " + lv_Tendency) lv_signal = self.pricedata_stadistics.iloc[ len(self.pricedata_stadistics) - 1]['signal'] self.logMessages = self.logMessages + "\n" + ( "MACD Signal: " + str(lv_signal) + " SubValuacion: " + str(self.macdsub) + " SobreValuacion: " + str(self.macduper)) self.logMessages = self.logMessages + "\n" + ("RSI " + str(iRSI[len(iRSI) - 1])) # data_per_d['lower_sto'] # if self.crossesOver(data_per_k, data_per_d) and lv_signal <= self.macdsub and \ # self.pricedata_stadistics.iloc[len(self.pricedata_stadistics) - 1]['signal'] > \ # self.pricedata_stadistics.iloc[len(self.pricedata_stadistics) - 1]['macd']: # if self.crossesOver(data_per_k, data_per_d) and lv_signal <= self.macdsub and \ # self.pricedata_stadistics.iloc[len(self.pricedata_stadistics) - 1]['signal'] > \ # self.pricedata_stadistics.iloc[len(self.pricedata_stadistics) - 1]['macd']: # if self.crossesOver(data_per_k, data_per_d) and data_per_d[len(data_per_d) - 1] <= 20 and \ # self.pricedata_stadistics.iloc[len(self.pricedata_stadistics) - 1]['bidclose'] > iFastSMA[ # len(iFastSMA) - 1]: if self.crossesOver(self.pricedata_stadistics['y'], self.pricedata_stadistics['y_pred'] ) and lv_Tendency == "Alcista": self.logMessages = self.logMessages + "\n" + " SEÑAL DE COMPRA ! \n" self.logMessages = self.logMessages + "\n" + (''' __,_, [_|_/ // _// __ (_|) |@@| \ \__ \--/ __ \o__|----| | __ \ }{ /\ )_ / _\_ /\__/\ \__O (__ (--/\--) \__/ _)( )(_ `---''---` ''') self.logMessages = self.logMessages + "\n" + " SEÑAL DE COMPRA !" if self.countOpenTrades("S") > 0: self.logMessages = self.logMessages + "\n" + " Cerrando Ventas Abiertas..." self.exit("S") self.logMessages = self.logMessages + "\n" + " Abrir Operacion de Compra..." if self.countOpenTrades("B") == 0: self.enter("B") # playsound("file_example_MP3_700KB.mp3") self.operacioncompra = True # Verifica el Cruce del SMA para Abajo. if self.crossesUnder(self.pricedata_stadistics['y'], self.pricedata_stadistics['y_pred'] ) and lv_Tendency == "Bajista": # if crossesUnder(pricedata_stadistics['signal'], 0.0004): # if self.crossesUnder(data_per_k, data_per_d) and lv_signal >= self.macduper and \ # self.pricedata_stadistics.iloc[len(self.pricedata_stadistics) - 1]['signal'] < \ # self.pricedata_stadistics.iloc[len(self.pricedata_stadistics) - 1]['macd']: # if self.crossesUnder(data_per_k, data_per_d) and data_per_d[len(data_per_d) - 1] >= 80 and \ # self.pricedata_stadistics.iloc[len(self.pricedata_stadistics) - 1]['bidclose'] < iFastSMA[ # len(iFastSMA) - 1]: self.logMessages = self.logMessages + "\n" + " SEÑAL DE VENTA ! \n" self.logMessages = self.logMessages + "\n" + (''' __ _ |@@| / \ \--/ __ ) O|----| | __ / / \ }{ /\ )_ / _\_ )/ /\__/\ \__O (__ |/ (--/\--) \__/ / _)( )(_ `---''---` ''') self.logMessages = self.logMessages + "\n" + " SEÑAL DE VENTA ! " if self.countOpenTrades("B") > 0: self.logMessages = self.logMessages + "\n" + " Cerrando Operacion de Compras..." self.exit("B") self.logMessages = self.logMessages + "\n" + " Abrir Operacion de Venta..." if self.countOpenTrades("S") == 0: self.enter("S") # playsound("file_example_MP3_700KB.mp3") self.operacionventa = True self.logMessages = self.logMessages + "\n" + ( str(dt.datetime.now()) + " " + self.timeframe + "Verificacion " "Realizada.\n")
def Update(): global pricedata_stadistics global pricedata_stadistics_sup print(str(dt.datetime.now()) + " " + timeframe + " Bar Closed - Running Update Function...") pricedata_stadistics['index'] = pricedata['bidclose'].index pricedata_stadistics['bidclose'] = pricedata['bidclose'].values pricedata_stadistics_sup['index'] = pricedata_sup['bidclose'].index pricedata_stadistics_sup['bidclose'] = pricedata_sup['bidclose'].values # Calculate Indicators iFastSMA = sma(pricedata['bidopen'], fast_sma_periods) iSlowSMA = sma(pricedata['bidclose'], slow_sma_periods) iSlowSMA2 = sma(pricedata_sup['bidopen'], slow_sma_periods2) pricedata_stadistics['emaFast'] = iFastSMA pricedata_stadistics['emaSlow'] = iSlowSMA pricedata_stadistics_sup['emaSlow2'] = iSlowSMA2 # Print Price/Indicators print("Close Price: " + str(pricedata_stadistics['bidclose'][len(pricedata) - 1])) #print("Fast SMA: " + str(iFastSMA[len(iFastSMA) - 1])) #print("Slow SMA Open SUP: " + str(iSlowSMA[len(iSlowSMA) - 1])) #print("Slow SMA Open SUP2: " + str(iSlowSMA2[len(iSlowSMA2) - 1])) # *********************************************************** # * Regresion al precio de cierre las velas ================ # *********************************************************** pricedata_stadistics['x'] = np.arange(len(pricedata_stadistics)) # ************* Calcular la poscion Relativa Y for index, row in pricedata_stadistics.iterrows(): pricedata_stadistics.loc[index, 'y'] = int( '{:.5f}'.format((pricedata_stadistics.loc[index, 'bidclose'])).replace('.', '')) max_value = max(np.array(pricedata_stadistics['y'].values)) min_value = min(np.array(pricedata_stadistics['y'].values)) for index, row in pricedata_stadistics.iterrows(): value = pricedata_stadistics.loc[index, 'y'] - min_value NewPricePosition = ((value * 100) / max_value) * 100 pricedata_stadistics.loc[index, 'y'] = NewPricePosition # *********** Calcular la poscion Relativa X max_value = max(np.array(pricedata_stadistics['x'].values)) min_value = min(np.array(pricedata_stadistics['x'].values)) for index, row in pricedata_stadistics.iterrows(): value = pricedata_stadistics.loc[index, 'x'] - min_value NewPricePosition = ((value * 100) / max_value) pricedata_stadistics.loc[index, 'x'] = NewPricePosition regresionLineal_xx = np.array(pricedata_stadistics['x'].values) regresionLineal_yy = np.array(pricedata_stadistics['y'].values) regresionLineal_bb = regresionlineal2.estimate_b0_b1(regresionLineal_xx, regresionLineal_yy) y_pred_sup = regresionLineal_bb[0] + regresionLineal_bb[1] * regresionLineal_xx pricedata_stadistics['y_pred'] = y_pred_sup # Recreacion del Eje X para Presentacion de la Regresion. # for index, row in pricedata_stadistics.iterrows(): # pricedata_stadistics.loc[index, 'x_pred'] = pricedata_stadistics.loc[0, 'y_pred'] # Calculo de Angulo vx = np.array(pricedata_stadistics['x']) vy = np.array(pricedata_stadistics['y_pred']) x1 = vx[0] y1 = vy[0] x2 = vx[-1] y2 = vy[-1] x = x2 - x1 y = y2 - y1 angle = math.atan2(y, x) * (180.0 / math.pi) angle = round(angle, 2) # angle2 = np.rad2deg(np.arctan2(vy[-1] - vy[0], vx[-1] - vx[0])) print("\nAngulo: " + str(angle)) lv_Tendency = "Lateral" if pricedata_stadistics.iloc[len(pricedata_stadistics) - 1]['y_pred'] < \ pricedata_stadistics.iloc[1]['y_pred'] and \ pricedata_stadistics.iloc[len(pricedata_stadistics) - 1]['y_pred'] < \ pricedata_stadistics.iloc[1]['y_pred']: lv_Tendency = "Bajista" elif pricedata_stadistics.iloc[len(pricedata_stadistics) - 1]['y_pred'] > \ pricedata_stadistics.iloc[1]['y_pred'] and \ pricedata_stadistics.iloc[len(pricedata_stadistics) - 1]['y_pred'] > \ pricedata_stadistics.iloc[1]['y_pred']: lv_Tendency = "Alcista" print("\nTendencia Regresion Lineal: " + lv_Tendency) # # TRADING LOGIC # # print("Slow SMA Open SUP: " + str(iSlowSMA[len(iSlowSMA) - 1])) # print("Slow SMA Open SUP2: " + str(iSlowSMA2[len(iSlowSMA2) - 1])) message_text = "" #if crossesOver(iFastSMA, iSlowSMA) and angle >= 1: if crossesOver(iFastSMA, iSlowSMA):# and lv_Tendency == "Alcista": message_text = message_text + "\n BUY SIGNAL!" if countOpenTrades("S") > 0: message_text = message_text + "\n Closing Sell Trade(s)..." exit("S") if countOpenTrades("B") == 0: message_text = message_text + "\n Opening Buy Trade..." enter("B") #if crossesUnder(iFastSMA, iSlowSMA) and angle <= -1: if crossesUnder(iFastSMA, iSlowSMA):# and lv_Tendency == "Bajista": message_text = message_text + "\n SELL SIGNAL!" if countOpenTrades("B") > 0: message_text = message_text + "\n Closing Buy Trade(s)..." exit("B") if countOpenTrades("S") == 0: message_text = message_text + "\n Opening Sell Trade..." enter("S") print(message_text) print(str(dt.datetime.now()) + " " + timeframe + " Update Function Completed.\n") print("\n")
def sma(self, df): period = 15 if len(df) < period: period = len(df) // 2 data = sma(df, 15) return (data)
def Update(): print( str(dt.datetime.now()) + " " + timeframe + " Bar Closed - Running Update Function...") # ********************************************************************* # ** Estadistica General - Regresion Lineal Simple 1 # ********************************************************************* pricedata_stadistics['bidclose'] = pricedata['bidclose'].values pricedata_stadistics['bidopen'] = pricedata['bidopen'].values pricedata_stadistics['date'] = pricedata['bidclose'].index # pricedata_stadistics['emaFast'] = pricedata_stadistics['bidclose'].rolling(window=fast_sma_periods).mean() # pricedata_stadistics['emaSlow'] = pricedata_stadistics['bidclose'].rolling(window=slow_sma_periods).mean() # Calculate Indicators iFastSMA = sma(pricedata['bidclose'], fast_sma_periods) iSlowSMA = sma(pricedata['bidclose'], slow_sma_periods) pricedata_stadistics['emaFast'] = iFastSMA pricedata_stadistics['emaSlow'] = iSlowSMA pricedata_stadistics.index = pricedata['bidclose'].index pricedata_stadistics['rowid'] = np.arange(len(pricedata_stadistics)) # ********************************************************************* # ** Estadistica General - Regresion Lineal # ********************************************************************* pricedata_stadistics_sup['bidclose'] = pricedata_sup['bidclose'].values pricedata_stadistics_sup['date'] = pricedata_sup['bidclose'].index pricedata_stadistics_sup['bidhigh'] = pricedata_sup['bidhigh'].values pricedata_stadistics_sup['bidlow'] = pricedata_sup['bidlow'].values pricedata_stadistics_sup.index = pricedata_sup['bidclose'].index pricedata_stadistics_sup['rowid'] = np.arange( len(pricedata_stadistics_sup)) # Regresion al mas Alto de las velas ====================== regresionLineal_xx_sup = np.array( pricedata_stadistics_sup['rowid'].tail(numberofregresion_sup).values) regresionLineal_yy_sup = np.array( pricedata_stadistics_sup['bidhigh'].tail(numberofregresion_sup).values) regresionLineal_bb_sup = regresionlineal2.estimate_b0_b1( regresionLineal_xx_sup, regresionLineal_yy_sup) y_pred_sup = regresionLineal_bb_sup[ 0] + regresionLineal_bb_sup[1] * regresionLineal_xx_sup numberRegx = len(pricedata_stadistics_sup) - numberofregresion_sup posreg = 0 for index, row in pricedata_stadistics_sup.iterrows(): if numberRegx <= pricedata_stadistics_sup.loc[index, 'rowid']: pricedata_stadistics_sup.loc[index, 'y_pred_bidhigh'] = y_pred_sup[posreg] posreg = posreg + 1 # Regresion al mas bajo de las velas ====================== regresionLineal_xx_sup = np.array( pricedata_stadistics_sup['rowid'].tail(numberofregresion_sup).values) regresionLineal_yy_sup = np.array( pricedata_stadistics_sup['bidlow'].tail(numberofregresion_sup).values) regresionLineal_bb_sup = regresionlineal2.estimate_b0_b1( regresionLineal_xx_sup, regresionLineal_yy_sup) y_pred_sup = regresionLineal_bb_sup[ 0] + regresionLineal_bb_sup[1] * regresionLineal_xx_sup numberRegx = len(pricedata_stadistics_sup) - numberofregresion_sup posreg = 0 for index, row in pricedata_stadistics_sup.iterrows(): if numberRegx <= pricedata_stadistics_sup.loc[index, 'rowid']: pricedata_stadistics_sup.loc[index, 'y_pred_bidlow'] = y_pred_sup[posreg] posreg = posreg + 1 # ********************************************************************* # *** Proyecion de Precios * Se puede Mejorar con Ciclo # ********************************************************************* lv_index_1 = pricedata_stadistics_sup.iloc[len(pricedata_stadistics_sup) - 1]['date'] lv_rowid_1 = pricedata_stadistics_sup.iloc[len(pricedata_stadistics_sup) - 1]['rowid'] lv_y_pred_askhigh_1 = pricedata_stadistics_sup.iloc[ len(pricedata_stadistics_sup) - 1]['y_pred_bidhigh'] lv_y_pred_asklow_1 = pricedata_stadistics_sup.iloc[ len(pricedata_stadistics_sup) - 1]['y_pred_bidlow'] lv_index_2 = pricedata_stadistics_sup.iloc[len(pricedata_stadistics_sup) - 2]['date'] lv_rowid_2 = pricedata_stadistics_sup.iloc[len(pricedata_stadistics_sup) - 2]['rowid'] lv_y_pred_askhigh_2 = pricedata_stadistics_sup.iloc[ len(pricedata_stadistics_sup) - 2]['y_pred_bidhigh'] lv_y_pred_asklow_2 = pricedata_stadistics_sup.iloc[ len(pricedata_stadistics_sup) - 2]['y_pred_bidlow'] lv_index_base = lv_index_1 - lv_index_2 lv_rowid_base = lv_rowid_1 - lv_rowid_2 lv_y_pred_askhigh_base = lv_y_pred_askhigh_1 - lv_y_pred_askhigh_2 lv_y_pred_asklow_base = lv_y_pred_asklow_1 - lv_y_pred_asklow_2 pricedata_stadistics_proyeccion.loc[lv_index_1] = pd.Series({ 'rowid': lv_rowid_1, 'y_pred_bidhigh': lv_y_pred_askhigh_1, 'y_pred_bidlow': lv_y_pred_asklow_1 }) pricedata_stadistics_proyeccion.loc[lv_index_1 + lv_index_base] = pd.Series({ 'rowid': lv_rowid_1 + lv_rowid_base, 'y_pred_bidhigh': lv_y_pred_askhigh_1 + lv_y_pred_askhigh_base, 'y_pred_bidlow': lv_y_pred_asklow_1 + lv_y_pred_asklow_base }) # Calculamos La tendencia con los valores de de la proyection las velas mas altas y mas bajas. lv_Tendency = "Lateral" if pricedata_stadistics_sup.iloc[len(pricedata_stadistics_sup) - 1]['y_pred_bidhigh'] < \ pricedata_stadistics_sup.iloc[1]['y_pred_bidhigh'] and \ pricedata_stadistics_sup.iloc[len(pricedata_stadistics_sup) - 1]['y_pred_bidlow'] < \ pricedata_stadistics_sup.iloc[1]['y_pred_bidlow']: lv_Tendency = "Bajista" elif pricedata_stadistics_sup.iloc[len(pricedata_stadistics_sup) - 1]['y_pred_bidhigh'] > \ pricedata_stadistics_sup.iloc[1]['y_pred_bidhigh'] and \ pricedata_stadistics_sup.iloc[len(pricedata_stadistics_sup) - 1]['y_pred_bidlow'] > \ pricedata_stadistics_sup.iloc[1]['y_pred_bidlow']: lv_Tendency = "Alcista" print("Tendencia Regresion Lineal: " + lv_Tendency) lv_posicion_venta = False lv_posicion_compra = False if lv_Tendency == "Bajista" and pricedata_stadistics_proyeccion.iloc[ len(pricedata_stadistics_proyeccion) - 1]['y_pred_bidhigh'] < pricedata_stadistics.iloc[ len(pricedata_stadistics) - 1]['bidclose']: lv_posicion_venta = True lv_posicion_compra = False elif lv_Tendency == "Alcista" and pricedata_stadistics_proyeccion.iloc[ len(pricedata_stadistics_proyeccion) - 1]['y_pred_bidlow'] > pricedata_stadistics.iloc[ len(pricedata_stadistics) - 1]['bidclose']: lv_posicion_venta = False lv_posicion_compra = True print("Posicion de Venta: " + str(lv_posicion_venta) + " Posicion de Compra: " + str(lv_posicion_compra)) # Print Price/Indicators print("Close Price: " + str(pricedata['bidclose'][len(pricedata) - 1])) #print("Fast SMA: " + str(iFastSMA[len(iFastSMA) - 1])) #print("Slow SMA: " + str(iSlowSMA[len(iSlowSMA) - 1])) # TRADING LOGIC if crossesOver(iFastSMA, iSlowSMA) and lv_posicion_compra: print(" BUY SIGNAL!") if countOpenTrades("S") > 0: print(" Closing Sell Trade(s)...") exit("S") if countOpenTrades("B") == 0: print(" Opening Buy Trade...") enter("B") if crossesUnder(iFastSMA, iSlowSMA) and lv_posicion_venta: print(" SELL SIGNAL!") if countOpenTrades("B") > 0: print(" Closing Buy Trade(s)...") exit("B") if countOpenTrades("S") == 0: print(" Opening Sell Trade...") enter("S") print( str(dt.datetime.now()) + " " + timeframe + " Update Function Completed.\n") print("\n")
def compute_simple_moving_average(df): df['sma'] = sma(df.close, 15)
def do_calculation(self, candle): dataset = self.market.candles[self.interval][-self.periods:] data = list(c[4] for c in dataset) self.value = round(sma(data, self.periods)[-1], 6) self.close = candle[4] self.timestamp = ohlcv_functions.convert_timestamp_to_date(candle[0])
def mov_av_5(history: List[LastSale]) -> list: prices = [i.Price.Amount for i in history] prices.reverse() mov_av = [i for i in list(sma(prices, 5))] mov_av.reverse() return mov_av
def Update(): global message_text message_text = message_text + ( '\n' + str(dt.datetime.now()) + " " + timeframe + " Bar Closed - Running Update Function..." + symbol) # ********************************************************************* # ** Estadistica General - Regresion Lineal Simple 1 # ********************************************************************* pricedata_stadistics.iloc[0:0] pricedata_stadistics['bidclose'] = pricedata['bidclose'].values pricedata_stadistics['bidopen'] = pricedata['bidopen'].values pricedata_stadistics['x'] = np.arange(len(pricedata_stadistics)) # ************* Calcular la poscion Relativa Y for index, row in pricedata_stadistics.iterrows(): pricedata_stadistics.loc[index, 'y'] = int( '{:.5f}'.format((pricedata_stadistics.loc[index, 'bidclose'])).replace('.', '')) max_value = max(np.array(pricedata_stadistics['y'].values)) min_value = min(np.array(pricedata_stadistics['y'].values)) for index, row in pricedata_stadistics.iterrows(): value = pricedata_stadistics.loc[index, 'y'] - min_value NewPricePosition = ((value * 100) / max_value) * 100 pricedata_stadistics.loc[index, 'y'] = NewPricePosition # *********** Calcular la poscion Relativa X max_value = max(np.array(pricedata_stadistics['x'].values)) min_value = min(np.array(pricedata_stadistics['x'].values)) for index, row in pricedata_stadistics.iterrows(): value = pricedata_stadistics.loc[index, 'x'] - min_value NewPricePosition = ((value * 100) / max_value) pricedata_stadistics.loc[index, 'x'] = NewPricePosition # *********************************************************** # * EMA'S================ # *********************************************************** iFastSMA = sma(pricedata_stadistics['y'], fast_sma_periods) iSlowSMA = sma(pricedata_stadistics['y'], slow_sma_periods) iTooSlowSMA = sma(pricedata_stadistics['y'], too_slow_sma_periods) pricedata_stadistics['emaFast'] = iFastSMA pricedata_stadistics['emaSlow'] = iSlowSMA pricedata_stadistics['emaTooSlow'] = iTooSlowSMA # *********************************************************** # * Regresion al precio de cierre las velas ================ # *********************************************************** regresionLineal_xx = np.array(pricedata_stadistics['x'].values) regresionLineal_yy = np.array(pricedata_stadistics['y'].values) regresionLineal_bb = regresionlineal2.estimate_b0_b1(regresionLineal_xx, regresionLineal_yy) y_pred_sup = regresionLineal_bb[0] + regresionLineal_bb[1] * regresionLineal_xx pricedata_stadistics['y_pred'] = y_pred_sup # Recreacion del Eje X para Presentacion de la Regresion. for index, row in pricedata_stadistics.iterrows(): pricedata_stadistics.loc[index, 'x_pred'] = pricedata_stadistics.loc[0, 'y_pred'] # Calculo de Angulo vx = np.array(pricedata_stadistics['x']) vy = np.array(pricedata_stadistics['y_pred']) x1 = vx[0] y1 = vy[0] x2 = vx[-1] y2 = vy[-1] x = x2 - x1 y = y2 - y1 angle = math.atan2(y, x) * (180.0 / math.pi) angle = round(angle, 2) # angle2 = np.rad2deg(np.arctan2(vy[-1] - vy[0], vx[-1] - vx[0])) message_text = message_text + "\nAngulo: " + str(angle) # # pricedata_stadistics['y_bidhigh'] = pricedata['bidhigh'].values # pricedata_stadistics['y_bidlow'] = pricedata['bidlow'].values # # ************* Calcular la poscion Relativa Y # for index, row in pricedata_stadistics.iterrows(): # pricedata_stadistics.loc[index, 'y_bidhigh'] = int( # '{:.5f}'.format((pricedata_stadistics.loc[index, 'y_bidhigh'])).replace('.', '')) # pricedata_stadistics.loc[index, 'y_bidlow'] = int( # '{:.5f}'.format((pricedata_stadistics.loc[index, 'y_bidlow'])).replace('.', '')) # # max_value = max(np.array(pricedata_stadistics['y_bidhigh'].values)) # min_value = min(np.array(pricedata_stadistics['y_bidhigh'].values)) # for index, row in pricedata_stadistics.iterrows(): # value = pricedata_stadistics.loc[index, 'y_bidhigh'] - min_value # NewPricePosition = ((value * 100) / max_value) * 100 # pricedata_stadistics.loc[index, 'y_bidhigh'] = NewPricePosition # # max_value = max(np.array(pricedata_stadistics['y_bidlow'].values)) # min_value = min(np.array(pricedata_stadistics['y_bidlow'].values)) # for index, row in pricedata_stadistics.iterrows(): # value = pricedata_stadistics.loc[index, 'y_bidlow'] - min_value # NewPricePosition = ((value * 100) / max_value) * 100 # pricedata_stadistics.loc[index, 'y_bidlow'] = NewPricePosition # # # Regresion al precio mas alto velas ====================== # regresionLineal_xx = np.array(pricedata_stadistics['x'].values) # regresionLineal_yy = np.array(pricedata_stadistics['y_bidhigh'].values) # regresionLineal_bb = regresionlineal2.estimate_b0_b1(regresionLineal_xx, regresionLineal_yy) # # y_pred_sup = regresionLineal_bb[0] + regresionLineal_bb[1] * regresionLineal_xx # pricedata_stadistics['y_pred_bidhigh'] = y_pred_sup # # # Regresion al precio de cierre las velas ====================== # regresionLineal_xx = np.array(pricedata_stadistics['x'].values) # regresionLineal_yy = np.array(pricedata_stadistics['y_bidlow'].values) # regresionLineal_bb = regresionlineal2.estimate_b0_b1(regresionLineal_xx, regresionLineal_yy) # y_pred_sup = regresionLineal_bb[0] + regresionLineal_bb[1] * regresionLineal_xx # pricedata_stadistics['y_pred_bidlow'] = y_pred_sup # # ********************************************************************* # # ** Estadistica General - Regresion Lineal # # ********************************************************************* # pricedata_stadistics_sup.iloc[0:0] # pricedata_stadistics_sup['bidclose'] = pricedata_sup['bidclose'].values # pricedata_stadistics_sup['bidhigh'] = pricedata_sup['bidhigh'].values # pricedata_stadistics_sup['bidlow'] = pricedata_sup['bidlow'].values # pricedata_stadistics_sup['rowid'] = np.arange(len(pricedata_stadistics_sup)) # # # *************BIDHIGH # # ************* Calcular la poscion Relativa Y # for index, row in pricedata_stadistics_sup.iterrows(): # pricedata_stadistics_sup.loc[index, 'Y_bidhigh'] = int( # '{:.5f}'.format((pricedata_stadistics_sup.loc[index, 'bidhigh'])).replace('.', '')) # # max_value = max(np.array(pricedata_stadistics_sup['Y_bidhigh'].values)) # min_value = min(np.array(pricedata_stadistics_sup['Y_bidhigh'].values)) # for index, row in pricedata_stadistics_sup.iterrows(): # value = pricedata_stadistics_sup.loc[index, 'Y_bidhigh'] - min_value # NewPricePosition = (value * 100) / max_value # pricedata_stadistics_sup.loc[index, 'Y_bidhigh'] = NewPricePosition # # # *********** Calcular la poscion Relativa X # max_value = max(np.array(pricedata_stadistics_sup['rowid'].values)) # for index, row in pricedata_stadistics_sup.iterrows(): # value = pricedata_stadistics_sup.loc[index, 'rowid'] # NewPricePosition = (value * 100) / max_value # pricedata_stadistics_sup.loc[index, 'X_bidhigh'] = NewPricePosition # # # Regresion al precio mas Alto de las velas ====================== # regresionLineal_xx_sup = np.array(pricedata_stadistics_sup['X_bidhigh'].values) # regresionLineal_yy_sup = np.array(pricedata_stadistics_sup['Y_bidhigh'].values) # regresionLineal_bb_sup = regresionlineal2.estimate_b0_b1(regresionLineal_xx_sup, regresionLineal_yy_sup) # y_pred_sup = regresionLineal_bb_sup[0] + regresionLineal_bb_sup[1] * regresionLineal_xx_sup # # pricedata_stadistics_sup['y_pred_bidhigh'] = y_pred_sup # pricedata_stadistics_sup['x_pred_bidhigh'] = regresionLineal_xx_sup # # # # # # *************BIDLOW # # ************* Calcular la poscion Relativa Y # for index, row in pricedata_stadistics_sup.iterrows(): # pricedata_stadistics_sup.loc[index, 'Y_bidlow'] = int( # '{:.5f}'.format((pricedata_stadistics_sup.loc[index, 'bidlow'])).replace('.', '')) # # max_value = max(np.array(pricedata_stadistics_sup['Y_bidlow'].values)) # min_value = min(np.array(pricedata_stadistics_sup['Y_bidlow'].values)) # for index, row in pricedata_stadistics_sup.iterrows(): # value = pricedata_stadistics_sup.loc[index, 'Y_bidlow'] - min_value # NewPricePosition = (value * 100) / max_value # pricedata_stadistics_sup.loc[index, 'Y_bidlow'] = NewPricePosition # # # *********** Calcular la poscion Relativa X # max_value = max(np.array(pricedata_stadistics_sup['rowid'].values)) # for index, row in pricedata_stadistics_sup.iterrows(): # value = pricedata_stadistics_sup.loc[index, 'rowid'] # NewPricePosition = (value * 100) / max_value # pricedata_stadistics_sup.loc[index, 'X_bidlow'] = NewPricePosition # # # # # # Regresion al precio mas Alto de las velas ====================== # regresionLineal_xx_sup = np.array(pricedata_stadistics_sup['X_bidlow'].values) # regresionLineal_yy_sup = np.array(pricedata_stadistics_sup['Y_bidhigh'].values) # regresionLineal_bb_sup = regresionlineal2.estimate_b0_b1(regresionLineal_xx_sup, regresionLineal_yy_sup) # y_pred_sup = regresionLineal_bb_sup[0] + regresionLineal_bb_sup[1] * regresionLineal_xx_sup # # pricedata_stadistics_sup['y_pred_bidlow'] = y_pred_sup # pricedata_stadistics_sup['x_pred_bidlow'] = regresionLineal_xx_sup # # # # # # # create circle # c = plt.Circle((x1, y1), radius=10, color='red', alpha=.3) # plt.gca().add_artist(c) # # #plt.text(x1, y1, str(round(angle, 2)) + ' °') # # Regresion al mas bajo de las velas ====================== # regresionLineal_xx_sup = np.array(pricedata_stadistics_sup['rowid'].tail(numberofregresion_sup).values) # regresionLineal_yy_sup = np.array(pricedata_stadistics_sup['bidlow'].tail(numberofregresion_sup).values) # regresionLineal_bb_sup = regresionlineal2.estimate_b0_b1(regresionLineal_xx_sup, regresionLineal_yy_sup) # y_pred_sup = regresionLineal_bb_sup[0] + regresionLineal_bb_sup[1] * regresionLineal_xx_sup # # numberRegx = len(pricedata_stadistics_sup) - numberofregresion_sup # posreg = 0 # for index, row in pricedata_stadistics_sup.iterrows(): # if numberRegx <= pricedata_stadistics_sup.loc[index, 'rowid']: # pricedata_stadistics_sup.loc[index, 'y_pred_bidlow'] = y_pred_sup[posreg] # posreg = posreg + 1 # # # ********************************************************************* # # *** Proyecion de Precios * Se puede Mejorar con Ciclo # # ********************************************************************* # lv_index_1 = pricedata_stadistics_sup.iloc[len(pricedata_stadistics_sup) - 1]['date'] # lv_rowid_1 = pricedata_stadistics_sup.iloc[len(pricedata_stadistics_sup) - 1]['rowid'] # lv_y_pred_askhigh_1 = pricedata_stadistics_sup.iloc[len(pricedata_stadistics_sup) - 1]['y_pred_bidhigh'] # lv_y_pred_asklow_1 = pricedata_stadistics_sup.iloc[len(pricedata_stadistics_sup) - 1]['y_pred_bidlow'] # # lv_index_2 = pricedata_stadistics_sup.iloc[len(pricedata_stadistics_sup) - 2]['date'] # lv_rowid_2 = pricedata_stadistics_sup.iloc[len(pricedata_stadistics_sup) - 2]['rowid'] # lv_y_pred_askhigh_2 = pricedata_stadistics_sup.iloc[len(pricedata_stadistics_sup) - 2]['y_pred_bidhigh'] # lv_y_pred_asklow_2 = pricedata_stadistics_sup.iloc[len(pricedata_stadistics_sup) - 2]['y_pred_bidlow'] # # lv_index_base = lv_index_1 - lv_index_2 # lv_rowid_base = lv_rowid_1 - lv_rowid_2 # lv_y_pred_askhigh_base = lv_y_pred_askhigh_1 - lv_y_pred_askhigh_2 # lv_y_pred_asklow_base = lv_y_pred_asklow_1 - lv_y_pred_asklow_2 # # pricedata_stadistics_proyeccion.iloc[0:0] # for proyect_times in range(2): # pricedata_stadistics_proyeccion.loc[lv_index_1] = pd.Series( # {'rowid': lv_rowid_1, # 'y_pred_bidhigh': lv_y_pred_askhigh_1, # 'y_pred_bidlow': lv_y_pred_asklow_1 # }) # lv_index_1 = lv_index_1 + lv_index_base # lv_rowid_1 = lv_rowid_1 + lv_rowid_base # lv_y_pred_askhigh_1 = lv_y_pred_askhigh_1 + lv_y_pred_askhigh_base # lv_y_pred_asklow_1 = lv_y_pred_asklow_1 + lv_y_pred_asklow_base # # pricedata_stadistics_proyeccion_tenden.iloc[0:0] # for proyect_times in range(3): # pricedata_stadistics_proyeccion_tenden.loc[lv_index_1] = pd.Series( # {'rowid': lv_rowid_1, # 'y_pred_bidhigh': lv_y_pred_askhigh_1, # 'y_pred_bidlow': lv_y_pred_asklow_1 # }) # lv_index_1 = lv_index_1 + lv_index_base # lv_rowid_1 = lv_rowid_1 + lv_rowid_base # lv_y_pred_askhigh_1 = lv_y_pred_askhigh_1 + lv_y_pred_askhigh_base # lv_y_pred_asklow_1 = lv_y_pred_asklow_1 + lv_y_pred_asklow_base # # Calculamos La tendencia con los valores de de la proyection las velas mas altas y mas bajas. lv_Tendency = "Lateral" if pricedata_stadistics.iloc[len(pricedata_stadistics) - 1]['y_pred'] < \ pricedata_stadistics.iloc[1]['y_pred'] and \ pricedata_stadistics.iloc[len(pricedata_stadistics) - 1]['y_pred'] < \ pricedata_stadistics.iloc[1]['y_pred']: lv_Tendency = "Bajista" elif pricedata_stadistics.iloc[len(pricedata_stadistics) - 1]['y_pred'] > \ pricedata_stadistics.iloc[1]['y_pred'] and \ pricedata_stadistics.iloc[len(pricedata_stadistics) - 1]['y_pred'] > \ pricedata_stadistics.iloc[1]['y_pred']: lv_Tendency = "Alcista" message_text = message_text + "\nTendencia Regresion Lineal: " + lv_Tendency lv_posicion_venta = False lv_posicion_compra = False if lv_Tendency == "Bajista" and (pricedata_stadistics.iloc[len(pricedata_stadistics) - 1]['emaTooSlow'] > pricedata_stadistics.iloc[len(pricedata_stadistics) - 1]['y']): lv_posicion_venta = True lv_posicion_compra = False elif lv_Tendency == "Alcista" and (pricedata_stadistics.iloc[len(pricedata_stadistics) - 1][ 'emaTooSlow'] < pricedata_stadistics.iloc[len(pricedata_stadistics) - 1][ 'y']): lv_posicion_venta = False lv_posicion_compra = True message_text = message_text + "\nPosicion de Venta: " + str(lv_posicion_venta) + " Posicion de Compra: " + str( lv_posicion_compra) # # Print Price/Indicators # print("Close Price: " + str(pricedata['bidclose'][len(pricedata) - 1])) # # print("Fast SMA: " + str(iFastSMA[len(iFastSMA) - 1])) # # print("Slow SMA: " + str(iSlowSMA[len(iSlowSMA) - 1])) # # # TRADING LOGIC # if crossesOver(iFastSMA, iSlowSMA) and lv_posicion_compra and angle >= angulo_plus: message_text = message_text + "\n BUY SIGNAL!" if countOpenTrades("S") > 0: message_text = message_text + "\n Closing Sell Trade(s)..." exit("S") if countOpenTrades("B") == 0: message_text = message_text + "\n Opening Buy Trade..." enter("B") if crossesUnder(iFastSMA, iSlowSMA) and lv_posicion_venta and angle <= angulo_minus: message_text = message_text + "\n SELL SIGNAL!" if countOpenTrades("B") > 0: message_text = message_text + "\n Closing Buy Trade(s)..." exit("B") if countOpenTrades("S") == 0: message_text = message_text + "\n Opening Sell Trade..." enter("S") message_text = message_text + "\n" + str( dt.datetime.now()) + " " + timeframe + " Update Function Completed.========= \n" print(message_text) message_text = ''
def Update(): print(''' [ ] ( ) |>| __/===\__ _/_/| o=o |\_\_ <] | o=o | [> \=====/ _/ / | \ \_ <_________> ''') print( str(dt.datetime.now()) + " " + timeframe + " Vela Formada - Analizando - Running Update Function...") iFastSMA = sma(pricedata['bidclose'], fast_sma_periods) iSlowSMA = sma(pricedata['bidclose'], slow_sma_periods) # Imprimir Precio/Indicador print("Precio Cierre: " + str(pricedata['bidclose'][len(pricedata) - 1])) print("Fast SMA: " + str(iFastSMA[len(iFastSMA) - 1])) print("Slow SMA: " + str(iSlowSMA[len(iSlowSMA) - 1])) print("Periodos de validacion:") print("fast_sma_periods:" + str(fast_sma_periods)) print("slow_sma_periods:" + str(slow_sma_periods)) print(pricedata) # Logica Robot # Verifica el Cruce del SMA para Arriba. if crossesOver(iFastSMA, iSlowSMA): print(" SEÑAL DE COMPRA ! \n") print(''' __,_, [_|_/ // _// __ (_|) |@@| \ \__ \--/ __ \o__|----| | __ \ }{ /\ )_ / _\_ /\__/\ \__O (__ (--/\--) \__/ _)( )(_ `---''---` ''') print(" SEÑAL DE COMPRA ! \n") if countOpenTrades("S") > 0: print(" Cerrando Ventas Abiertas...\n") exit("S") print(" Abrir Operacion de Compra...\n") enter("B") # Verifica el Cruce del SMA para Abajo. if crossesUnder(iFastSMA, iSlowSMA): print(" SEÑAL DE VENTA ! \n") print(''' __ _ |@@| / \ \--/ __ ) O|----| | __ / / \ }{ /\ )_ / _\_ )/ /\__/\ \__O (__ |/ (--/\--) \__/ / _)( )(_ `---''---` ''') print(" SEÑAL DE VENTA ! \n") if countOpenTrades("B") > 0: print(" Cerrando Operacion de Compras...\n") exit("B") print(" Abrir Operacion de Venta...\n") enter("S") print( str(dt.datetime.now()) + " " + timeframe + " Verificacion Realizada.\n") print("\n")
def Update(): global pricedata_stadistics, operacionventa, operacioncompra print(str(dt.datetime.now()) + " " + timeframe + " Vela Formada - Analizando - Running Update Function...") pricedata_stadistics['index'] = pricedata['bidclose'].index pricedata_stadistics['bidclose'] = pricedata['bidclose'].values pricedata_stadistics['bidhigh'] = pricedata['bidhigh'].values pricedata_stadistics['askclose'] = pricedata['askclose'].values pricedata_stadistics['askhigh'] = pricedata['askhigh'].values pricedata_stadistics['asklow'] = pricedata['asklow'].values pricedata_stadistics['askclose'] = pricedata['askclose'].values pricedata_stadistics['bidlow'] = pricedata['bidlow'].values pricedata_stadistics['tickqty'] = pricedata['tickqty'].values # Calculate Indicators iFastSMA = sma(pricedata['bidclose'], fast_sma_periods) iSlowSMA = sma(pricedata['bidclose'], slow_sma_periods) pricedata_stadistics['emaFast'] = iFastSMA pricedata_stadistics['emaSlow'] = iSlowSMA # Adds a "n_high" column with max value of previous 14 periods pricedata_stadistics['n_high'] = pricedata_stadistics['bidhigh'].rolling(stoK).max() # Adds an "n_low" column with min value of previous 14 periods pricedata_stadistics['n_low'] = pricedata_stadistics['bidlow'].rolling(stoK).min() # Uses the min/max values to calculate the %k (as a percentage) pricedata_stadistics['per_k'] = (pricedata_stadistics['bidclose'] - pricedata_stadistics['n_low']) * 100 / ( pricedata_stadistics['n_high'] - pricedata_stadistics['n_low']) # Uses the %k to calculates a SMA over the past 3 values of %k pricedata_stadistics['per_d'] = pricedata_stadistics['per_k'].rolling(stoD).mean() # data_per_k = per_k(pricedata['bidclose'], stoK) # data_per_d = per_d(pricedata['bidclose'], stoD) data_per_k = pricedata_stadistics['per_k'] data_per_d = pricedata_stadistics['per_d'] # pricedata_stadistics['per_k'] = data_per_k # pricedata_stadistics['per_d'] = data_per_d # Calcular Indicador iRSI = rsi(pricedata_stadistics['bidclose'], 15) print("RSI: " + str(iRSI[len(iRSI) - 1])) for index, row in pricedata_stadistics.iterrows(): pricedata_stadistics.loc[index, 'lower_sto'] = 20 pricedata_stadistics.loc[index, 'upper_sto'] = 80 pricedata_stadistics.loc[index, 'macdline0'] = 0.00 # *********************************************************** # * Regresion al precio de cierre las velas ================ # *********************************************************** pricedata_stadistics['x'] = np.arange(len(pricedata_stadistics)) # ************* Calcular la poscion Relativa Y for index, row in pricedata_stadistics.iterrows(): pricedata_stadistics.loc[index, 'y'] = int( '{:.5f}'.format((pricedata_stadistics.loc[index, 'bidclose'])).replace('.', '')) max_value = max(np.array(pricedata_stadistics['y'].values)) min_value = min(np.array(pricedata_stadistics['y'].values)) for index, row in pricedata_stadistics.iterrows(): value = pricedata_stadistics.loc[index, 'y'] - min_value NewPricePosition = ((value * 100) / max_value) * 100 pricedata_stadistics.loc[index, 'y'] = NewPricePosition # *********** Calcular la poscion Relativa X max_value = max(np.array(pricedata_stadistics['x'].values)) min_value = min(np.array(pricedata_stadistics['x'].values)) for index, row in pricedata_stadistics.iterrows(): value = pricedata_stadistics.loc[index, 'x'] - min_value NewPricePosition = ((value * 100) / max_value) pricedata_stadistics.loc[index, 'x'] = NewPricePosition regresionLineal_xx = np.array(pricedata_stadistics['x'].values) regresionLineal_yy = np.array(pricedata_stadistics['y'].values) regresionLineal_bb = regresionlineal2.estimate_b0_b1(regresionLineal_xx, regresionLineal_yy) y_pred_sup = regresionLineal_bb[0] + regresionLineal_bb[1] * regresionLineal_xx pricedata_stadistics['y_pred'] = y_pred_sup if pricedata_stadistics.iloc[len(pricedata_stadistics) - 1]['y_pred'] < \ pricedata_stadistics.iloc[1]['y_pred'] and \ pricedata_stadistics.iloc[len(pricedata_stadistics) - 1]['y_pred'] < \ pricedata_stadistics.iloc[1]['y_pred']: lv_Tendency = "Bajista" elif pricedata_stadistics.iloc[len(pricedata_stadistics) - 1]['y_pred'] > \ pricedata_stadistics.iloc[1]['y_pred'] and \ pricedata_stadistics.iloc[len(pricedata_stadistics) - 1]['y_pred'] > \ pricedata_stadistics.iloc[1]['y_pred']: lv_Tendency = "Alcista" # MACD ######################################################################## exp1 = pricedata_stadistics['bidclose'].ewm(span=macdFast, adjust=False).mean() exp2 = pricedata_stadistics['bidclose'].ewm(span=macdSlow, adjust=False).mean() macd = exp1 - exp2 pricedata_stadistics['macd'] = pricedata_stadistics.index.map(macd) pricedata_stadistics['signal'] = pd.DataFrame( pricedata_stadistics['macd'].ewm(span=macdSmooth, adjust=False).mean()) pricedata_stadistics['hist'] = pd.DataFrame(pricedata_stadistics['macd'] - pricedata_stadistics['signal']) # Imprimir Precio/Indicador # print("Precio Cierre: " + str(pricedata['bidclose'][len(pricedata) - 1])) # print("Tendencia Regresion Lineal: " + lv_Tendency) lv_signal = pricedata_stadistics.iloc[len(pricedata_stadistics) - 1]['signal'] print("MACD Signal: " + str(lv_signal) + " SubValuacion: " + str(macdsub) + " SobreValuacion: " + str(macduper)) print("STO D" + str(data_per_d[len(data_per_d) - 1])) if iRSI[len(iRSI) - 1] <= 40 and crossesOver(data_per_d, pricedata_stadistics['lower_sto']) and lv_signal <= macdsub: print(" SEÑAL DE COMPRA ! \n") print(''' __,_, [_|_/ // _// __ (_|) |@@| \ \__ \--/ __ \o__|----| | __ \ }{ /\ )_ / _\_ /\__/\ \__O (__ (--/\--) \__/ _)( )(_ `---''---` ''') print(" SEÑAL DE COMPRA ! \n") if countOpenTrades("S") > 0: print(" Cerrando Ventas Abiertas...\n") exit("S") print(" Abrir Operacion de Compra...\n") if countOpenTrades("B") == 0: enter("B") operacioncompra = True # Verifica el Cruce del SMA para Abajo. # if crossesUnder(data_per_d, 0.80): # if crossesUnder(pricedata_stadistics['signal'], 0.0004): if iRSI[len(iRSI) - 1] >= 60 and crossesUnder(data_per_d, pricedata_stadistics['upper_sto']) and lv_signal >= macduper: print(" SEÑAL DE VENTA ! \n") print(''' __ _ |@@| / \ \--/ __ ) O|----| | __ / / \ }{ /\ )_ / _\_ )/ /\__/\ \__O (__ |/ (--/\--) \__/ / _)( )(_ `---''---` ''') print(" SEÑAL DE VENTA ! \n") if countOpenTrades("B") > 0: print(" Cerrando Operacion de Compras...\n") exit("B") print(" Abrir Operacion de Venta...\n") if countOpenTrades("S") == 0: enter("S") operacionventa = True # Cerrar Ventas ######################################### if operacionventa and crossesOver(data_per_d, pricedata_stadistics['lower_sto']): if countOpenTrades("S") > 0: print(" Cerrando Ventas Abiertas...\n") operacionventa = False exit("S") # Cerrar Compras ######################################### if operacioncompra and crossesUnder(data_per_d, pricedata_stadistics['upper_sto']): if countOpenTrades("B") > 0: print(" Cerrando Compras Abiertas...\n") operacioncompra = False exit("B") print(str(dt.datetime.now()) + " " + timeframe + " Verificacion Realizada.\n")
def simple_moving_average(data, period): return sma(data, period)