Пример #1
0
def T3(ohlcv, kw):
    """ :return Triple Exponential Moving Average (t3) """
    params = {'timeperiod': 5, 'vfactor': 0}
    timeperiod, vfactor = _get_params(kw, params, ['timeperiod', 'vfactor'])
    result = talib.T3(ohlcv, timeperiod, vfactor)
    return {
        't3': result
    }
Пример #2
0
def PMAX(dataframe, period=4, multiplier=0.1, length=4, MAtype=7, src=1):
    import talib.abstract as ta
    df = dataframe.copy()
    mavalue = 'MA_' + str(MAtype) + '_' + str(length)
    atr = 'ATR_' + str(period)
    df[atr] = ta.ATR(df, timeperiod=period)
    pm = 'pm_' + str(period) + '_' + str(multiplier) + '_' + str(length) + '_' + str(MAtype)
    pmx = 'pmX_' + str(period) + '_' + str(multiplier) + '_' + str(length) + '_' + str(MAtype)

    if src == 1:
        masrc = df["close"]
    elif src == 2:
        masrc = (df["high"] + df["low"]) / 2
    elif src == 3:
        masrc = (df["high"] + df["low"] + df["close"] + df["open"]) / 4
    if MAtype == 1:
        df[mavalue] = ta.EMA(masrc, timeperiod=length)
    elif MAtype == 2:
        df[mavalue] = ta.DEMA(masrc, timeperiod=length)
    elif MAtype == 3:
        df[mavalue] = ta.T3(masrc, timeperiod=length)
    elif MAtype == 4:
        df[mavalue] = ta.SMA(masrc, timeperiod=length)
    elif MAtype == 5:
        df[mavalue] = VIDYA(df, length=length)
    elif MAtype == 6:
        df[mavalue] = ta.TEMA(masrc, timeperiod=length)
    elif MAtype == 7:
        df[mavalue] = ta.WMA(df, timeperiod=length)
    elif MAtype == 8:
        df[mavalue] = vwma(df, length)
    elif MAtype == 9:
        df[mavalue] = zema(df, period=length)
    # Compute basic upper and lower bands
    df['basic_ub'] = df[mavalue] + (multiplier * df[atr])
    df['basic_lb'] = df[mavalue] - (multiplier * df[atr])
    # Compute final upper and lower bands
    df['final_ub'] = 0.00
    df['final_lb'] = 0.00
    for i in range(period, len(df)):
        df['final_ub'].iat[i] = df['basic_ub'].iat[i] if (
            df['basic_ub'].iat[i] < df['final_ub'].iat[i - 1]
            or df[mavalue].iat[i - 1] > df['final_ub'].iat[i - 1]) else df['final_ub'].iat[i - 1]
        df['final_lb'].iat[i] = df['basic_lb'].iat[i] if (
            df['basic_lb'].iat[i] > df['final_lb'].iat[i - 1]
            or df[mavalue].iat[i - 1] < df['final_lb'].iat[i - 1]) else df['final_lb'].iat[i - 1]

    df[pm] = 0.00
    for i in range(period, len(df)):
        df[pm].iat[i] = (
            df['final_ub'].iat[i] if (df[pm].iat[i - 1] == df['final_ub'].iat[i - 1]
                                      and df[mavalue].iat[i] <= df['final_ub'].iat[i])
            else df['final_lb'].iat[i] if (
                df[pm].iat[i - 1] == df['final_ub'].iat[i - 1]
                and df[mavalue].iat[i] > df['final_ub'].iat[i]) else df['final_lb'].iat[i]
            if (df[pm].iat[i - 1] == df['final_lb'].iat[i - 1]
                and df[mavalue].iat[i] >= df['final_lb'].iat[i]) else df['final_ub'].iat[i]
            if (df[pm].iat[i - 1] == df['final_lb'].iat[i - 1]
                and df[mavalue].iat[i] < df['final_lb'].iat[i]) else 0.00)

    # up/down belirteçi / main logic
    df[pmx] = np.where((df[pm] > 0.00), np.where((df[mavalue] < df[pm]), 'down',  'up'), np.NaN)
    
    df.drop(['basic_ub', 'basic_lb', 'final_ub', 'final_lb'], inplace=True, axis=1)

    df.fillna(0, inplace=True)

    return df
Пример #3
0
    def slow_tf_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:

        """
        # dataframe "1d"
        """

        dataframe1d = self.dp.get_pair_dataframe(
            pair=metadata['pair'], timeframe="1d")

        # Pivots Points
        pp = pivots_points(dataframe1d)
        dataframe1d['pivot'] = pp['pivot']
        dataframe1d['r1'] = pp['r1']
        dataframe1d['s1'] = pp['s1']
        dataframe1d['rS1'] = pp['rS1']
        dataframe1d['rS2'] = pp['rS2']
        dataframe1d['rS3'] = pp['rS3']


        dataframe = merge_informative_pair(
            dataframe, dataframe1d, self.timeframe, "1d", ffill=True)

        """
        # dataframe "1h"
        """
        dataframe1h = self.dp.get_pair_dataframe(
            pair=metadata['pair'], timeframe="1h")

        create_ichimoku(dataframe1h, conversion_line_period=20, 
                        displacement=9, base_line_periods=88, laggin_span=88)


        dataframe = merge_informative_pair(
            dataframe, dataframe1h, self.timeframe, "1h", ffill=True)

        """
        # dataframe "30m"
        """
        dataframe30m = self.dp.get_pair_dataframe(
            pair=metadata['pair'], timeframe="30m")

        dataframe30m['T33'] = ta.T3(dataframe30m, timeperiod=33)



        dataframe = merge_informative_pair(
            dataframe, dataframe30m, self.timeframe, "30m", ffill=True)

        """
        # dataframe normal "5m"
        """
        create_ichimoku(dataframe, conversion_line_period=200, 
                        displacement=88, base_line_periods=200, laggin_span=88)

        dataframe['ema20'] = ta.EMA(dataframe, timeperiod=20)
        dataframe['ema88'] = ta.EMA(dataframe, timeperiod=88)
        dataframe['ema440'] = ta.EMA(dataframe, timeperiod=440)
        dataframe['T88'] = ta.T3(dataframe, timeperiod=88)




        """
        NOTE: Start Trading

        """

        # Start Trading

        dataframe['trending_start'] = (
            (dataframe['close'] > dataframe['senkou_b_20_1h']) &
            (dataframe['close'] > dataframe['tenkan_sen_20_1h']) &
            (dataframe['tenkan_sen_20_1h'] > dataframe['senkou_a_200']) &
            (dataframe['tenkan_sen_20_1h'] > dataframe['T33_30m']) &
            (dataframe['ema88'] > dataframe['ema440']) &
            (dataframe['ema88'] > dataframe['T88']) &
            (dataframe['ema20'] > dataframe['ema88']) &
            (dataframe['close'] > dataframe['pivot_1d']) &
            (dataframe['close'] < dataframe['rS1_1d'])
        ).astype('int')        

        
        dataframe['trending_over'] = (
            (dataframe['ema88'] < dataframe['T88']) &
            (dataframe['close'] < dataframe['tenkan_sen_20_1h'])
        ).astype('int')

        return dataframe