X2: buy 1 - rework (dummy).

iterativv · iterativv · commit 3e21a6aed419 · 2022-03-05T12:40:31.000+02:00
diff --git a/experimental/NostalgiaForInfinityX2.py b/experimental/NostalgiaForInfinityX2.py
@@ -685,9 +685,380 @@ def populate_buy_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
                 item_buy_logic = []
                 item_buy_logic.append(reduce(lambda x, y: x & y, item_buy_protection_list))
 
-                # Condition #1 - Describe
+                # Condition #1 -
+
+        # Long mode, bear
+        if all(c in ['11'] for c in buy_tags):
+            sell, signal_name = self.sell_long_bear(current_profit, max_profit, max_loss, last_candle, previous_candle_1, previous_candle_2, previous_candle_3, previous_candle_4, previous_candle_5, trade, current_time, buy_tag)
+            if sell and (signal_name is not None):
+                return f"{signal_name} ( {buy_tag})"
+
+        return None
+
+    def informative_pairs(self):
+        # get access to all pairs available in whitelist.
+        pairs = self.dp.current_whitelist()
+        # Assign tf to each pair so they can be downloaded and cached for strategy.
+        informative_pairs = []
+        for info_timeframe in self.info_timeframes:
+            informative_pairs.extend([(pair, info_timeframe) for pair in pairs])
+
+        if self.config['stake_currency'] in ['USDT','BUSD','USDC','DAI','TUSD','PAX','USD','EUR','GBP']:
+            btc_info_pair = f"BTC/{self.config['stake_currency']}"
+        else:
+            btc_info_pair = "BTC/USDT"
+
+        informative_pairs.extend([(btc_info_pair, btc_info_timeframe) for btc_info_timeframe in self.btc_info_timeframes])
+
+        return informative_pairs
+
+    def informative_1d_indicators(self, metadata: dict, info_timeframe) -> DataFrame:
+        tik = time.perf_counter()
+        assert self.dp, "DataProvider is required for multiple timeframes."
+        # Get the informative pair
+        informative_1d = self.dp.get_pair_dataframe(pair=metadata['pair'], timeframe=info_timeframe)
+
+        # Indicators
+        # -----------------------------------------------------------------------------------------
+        informative_1d['rsi_14'] = ta.RSI(informative_1d, timeperiod=14)
+
+        # Performance logging
+        # -----------------------------------------------------------------------------------------
+        tok = time.perf_counter()
+        log.debug(f"[{metadata['pair']}] informative_1d_indicators took: {tok - tik:0.4f} seconds.")
+
+        return informative_1d
+
+    def informative_4h_indicators(self, metadata: dict, info_timeframe) -> DataFrame:
+        tik = time.perf_counter()
+        assert self.dp, "DataProvider is required for multiple timeframes."
+        # Get the informative pair
+        informative_4h = self.dp.get_pair_dataframe(pair=metadata['pair'], timeframe=info_timeframe)
+
+        # Indicators
+        # -----------------------------------------------------------------------------------------
+        # RSI
+        informative_4h['rsi_14'] = ta.RSI(informative_4h, timeperiod=14, fillna=True)
+
+        # SMA
+        informative_4h['sma_200'] = ta.SMA(informative_4h, timeperiod=200, fillna=True)
+
+        # Williams %R
+        informative_4h['r_14'] = williams_r(informative_4h, period=14)
+        informative_4h['r_480'] = williams_r(informative_4h, period=480)
+
+        # Performance logging
+        # -----------------------------------------------------------------------------------------
+        tok = time.perf_counter()
+        log.debug(f"[{metadata['pair']}] informative_1d_indicators took: {tok - tik:0.4f} seconds.")
+
+        return informative_4h
+
+    def informative_1h_indicators(self, metadata: dict, info_timeframe) -> DataFrame:
+        tik = time.perf_counter()
+        assert self.dp, "DataProvider is required for multiple timeframes."
+        # Get the informative pair
+        informative_1h = self.dp.get_pair_dataframe(pair=metadata['pair'], timeframe=info_timeframe)
+
+        # Indicators
+        # -----------------------------------------------------------------------------------------
+        # RSI
+        informative_1h['rsi_14'] = ta.RSI(informative_1h, timeperiod=14)
+
+        # SMA
+        informative_1h['sma_50'] = ta.SMA(informative_1h, timeperiod=50)
+        informative_1h['sma_100'] = ta.SMA(informative_1h, timeperiod=100)
+        informative_1h['sma_200'] = ta.SMA(informative_1h, timeperiod=200)
+
+        # BB
+        bollinger = qtpylib.bollinger_bands(qtpylib.typical_price(informative_1h), window=20, stds=2)
+        informative_1h['bb20_2_low'] = bollinger['lower']
+        informative_1h['bb20_2_mid'] = bollinger['mid']
+        informative_1h['bb20_2_upp'] = bollinger['upper']
+
+        # Williams %R
+        informative_1h['r_14'] = williams_r(informative_1h, period=14)
+        informative_1h['r_480'] = williams_r(informative_1h, period=480)
+
+        # Performance logging
+        # -----------------------------------------------------------------------------------------
+        tok = time.perf_counter()
+        log.debug(f"[{metadata['pair']}] informative_1h_indicators took: {tok - tik:0.4f} seconds.")
+
+        return informative_1h
+
+    def informative_15m_indicators(self, metadata: dict, info_timeframe) -> DataFrame:
+        tik = time.perf_counter()
+        assert self.dp, "DataProvider is required for multiple timeframes."
+
+        # Get the informative pair
+        informative_15m = self.dp.get_pair_dataframe(pair=metadata['pair'], timeframe=info_timeframe)
+
+        # Indicators
+        # -----------------------------------------------------------------------------------------
+        informative_15m['rsi_14'] = ta.RSI(informative_15m, timeperiod=14)
+
+        # Performance logging
+        # -----------------------------------------------------------------------------------------
+        tok = time.perf_counter()
+        log.debug(f"[{metadata['pair']}] informative_15m_indicators took: {tok - tik:0.4f} seconds.")
+
+        return informative_15m
+
+    # Coin Pair Base Timeframe Indicators
+    # ---------------------------------------------------------------------------------------------
+    def base_tf_5m_indicators(self,  metadata: dict, dataframe: DataFrame) -> DataFrame:
+        tik = time.perf_counter()
+
+        # Indicators
+        # -----------------------------------------------------------------------------------------
+        # RSI
+        dataframe['rsi_14'] = ta.RSI(dataframe, timeperiod=14)
+
+        # EMA
+        dataframe['ema_12'] = ta.EMA(dataframe, timeperiod=12)
+        dataframe['ema_26'] = ta.EMA(dataframe, timeperiod=26)
+        dataframe['ema_50'] = ta.EMA(dataframe, timeperiod=50)
+        dataframe['ema_200'] = ta.EMA(dataframe, timeperiod=200)
+
+        # SMA
+        dataframe['sma_50'] = ta.SMA(dataframe, timeperiod=50)
+        dataframe['sma_200'] = ta.SMA(dataframe, timeperiod=200)
+
+        # BB 20 - STD2
+        bb_20_std2 = qtpylib.bollinger_bands(qtpylib.typical_price(dataframe), window=20, stds=2)
+        dataframe['bb20_2_low'] = bb_20_std2['lower']
+        dataframe['bb20_2_mid'] = bb_20_std2['mid']
+        dataframe['bb20_2_upp'] = bb_20_std2['upper']
+
+        # Williams %R
+        dataframe['r_14'] = williams_r(dataframe, period=14)
+        dataframe['r_480'] = williams_r(dataframe, period=480)
+
+        # For sell checks
+        dataframe['crossed_below_ema_12_26'] = qtpylib.crossed_below(dataframe['ema_12'], dataframe['ema_26'])
+
+        # Global protections
+        # -----------------------------------------------------------------------------------------
+        if not self.config['runmode'].value in ('live', 'dry_run'):
+            # Backtest age filter
+            dataframe['bt_agefilter_ok'] = False
+            dataframe.loc[dataframe.index > (12 * 24 * self.bt_min_age_days),'bt_agefilter_ok'] = True
+        else:
+            # Exchange downtime protection
+            dataframe['live_data_ok'] = (dataframe['volume'].rolling(window=72, min_periods=72).min() > 0)
+
+        # Performance logging
+        # -----------------------------------------------------------------------------------------
+        tok = time.perf_counter()
+        log.debug(f"[{metadata['pair']}] base_tf_5m_indicators took: {tok - tik:0.4f} seconds.")
+
+        return dataframe
+
+    # Coin Pair Indicator Switch Case
+    # ---------------------------------------------------------------------------------------------
+    def info_switcher(self, metadata: dict, info_timeframe) -> DataFrame:
+        if info_timeframe == '1d':
+            return self.informative_1d_indicators(metadata, info_timeframe)
+        elif info_timeframe == '4h':
+            return self.informative_4h_indicators(metadata, info_timeframe)
+        elif info_timeframe == '1h':
+            return self.informative_1h_indicators(metadata, info_timeframe)
+        elif info_timeframe == '15m':
+            return self.informative_15m_indicators(metadata, info_timeframe)
+        else:
+            raise RuntimeError(f"{info_timeframe} not supported as informative timeframe for BTC pair.")
+
+    # BTC 1D Indicators
+    # ---------------------------------------------------------------------------------------------
+    def btc_info_1d_indicators(self, btc_info_pair, btc_info_timeframe, metadata: dict) -> DataFrame:
+        tik = time.perf_counter()
+        btc_info_1d = self.dp.get_pair_dataframe(btc_info_pair, btc_info_timeframe)
+        # Indicators
+        # -----------------------------------------------------------------------------------------
+        btc_info_1d['rsi_14'] = ta.RSI(btc_info_1d, timeperiod=14)
+        #btc_info_1d['pivot'], btc_info_1d['res1'], btc_info_1d['res2'], btc_info_1d['res3'], btc_info_1d['sup1'], btc_info_1d['sup2'], btc_info_1d['sup3'] = pivot_points(btc_info_1d, mode='fibonacci')
+
+        # Add prefix
+        # -----------------------------------------------------------------------------------------
+        ignore_columns = ['date']
+        btc_info_1d.rename(columns=lambda s: f"btc_{s}" if s not in ignore_columns else s, inplace=True)
+
+        tok = time.perf_counter()
+        log.debug(f"[{metadata['pair']}] btc_info_1d_indicators took: {tok - tik:0.4f} seconds.")
+
+        return btc_info_1d
+
+    # BTC 4h Indicators
+    # ---------------------------------------------------------------------------------------------
+    def btc_info_4h_indicators(self, btc_info_pair, btc_info_timeframe, metadata: dict) -> DataFrame:
+        tik = time.perf_counter()
+        btc_info_4h = self.dp.get_pair_dataframe(btc_info_pair, btc_info_timeframe)
+        # Indicators
+        # -----------------------------------------------------------------------------------------
+        # RSI
+        btc_info_4h['rsi_14'] = ta.RSI(btc_info_4h, timeperiod=14)
+
+        # SMA
+        btc_info_4h['sma_200'] = ta.SMA(btc_info_4h, timeperiod=200)
+
+        # Add prefix
+        # -----------------------------------------------------------------------------------------
+        ignore_columns = ['date']
+        btc_info_4h.rename(columns=lambda s: f"btc_{s}" if s not in ignore_columns else s, inplace=True)
+
+        tok = time.perf_counter()
+        log.debug(f"[{metadata['pair']}] btc_info_4h_indicators took: {tok - tik:0.4f} seconds.")
+
+        return btc_info_4h
+
+    # BTC 1h Indicators
+    # ---------------------------------------------------------------------------------------------
+    def btc_info_1h_indicators(self, btc_info_pair, btc_info_timeframe, metadata: dict) -> DataFrame:
+        tik = time.perf_counter()
+        btc_info_1h = self.dp.get_pair_dataframe(btc_info_pair, btc_info_timeframe)
+        # Indicators
+        # -----------------------------------------------------------------------------------------
+        btc_info_1h['rsi_14'] = ta.RSI(btc_info_1h, timeperiod=14)
+        btc_info_1h['not_downtrend'] = ((btc_info_1h['close'] > btc_info_1h['close'].shift(2)) | (btc_info_1h['rsi_14'] > 50))
+
+        # Add prefix
+        # -----------------------------------------------------------------------------------------
+        ignore_columns = ['date']
+        btc_info_1h.rename(columns=lambda s: f"btc_{s}" if s not in ignore_columns else s, inplace=True)
+
+        tok = time.perf_counter()
+        log.debug(f"[{metadata['pair']}] btc_info_1h_indicators took: {tok - tik:0.4f} seconds.")
+
+        return btc_info_1h
+
+    # BTC 15m Indicators
+    # ---------------------------------------------------------------------------------------------
+    def btc_info_15m_indicators(self, btc_info_pair, btc_info_timeframe, metadata: dict) -> DataFrame:
+        tik = time.perf_counter()
+        btc_info_15m = self.dp.get_pair_dataframe(btc_info_pair, btc_info_timeframe)
+        # Indicators
+        # -----------------------------------------------------------------------------------------
+        btc_info_15m['rsi_14'] = ta.RSI(btc_info_15m, timeperiod=14)
+
+        # Add prefix
+        # -----------------------------------------------------------------------------------------
+        ignore_columns = ['date']
+        btc_info_15m.rename(columns=lambda s: f"btc_{s}" if s not in ignore_columns else s, inplace=True)
+
+        tok = time.perf_counter()
+        log.debug(f"[{metadata['pair']}] btc_info_15m_indicators took: {tok - tik:0.4f} seconds.")
+
+        return btc_info_15m
+
+    # BTC 5m Indicators
+    # ---------------------------------------------------------------------------------------------
+    def btc_info_5m_indicators(self, btc_info_pair, btc_info_timeframe, metadata: dict) -> DataFrame:
+        tik = time.perf_counter()
+        btc_info_5m = self.dp.get_pair_dataframe(btc_info_pair, btc_info_timeframe)
+        # Indicators
+        # -----------------------------------------------------------------------------------------
+        btc_info_5m['rsi_14'] = ta.RSI(btc_info_5m, timeperiod=14)
+
+        # Add prefix
+        # -----------------------------------------------------------------------------------------
+        ignore_columns = ['date']
+        btc_info_5m.rename(columns=lambda s: f"btc_{s}" if s not in ignore_columns else s, inplace=True)
+
+        tok = time.perf_counter()
+        log.debug(f"[{metadata['pair']}] btc_info_5m_indicators took: {tok - tik:0.4f} seconds.")
+
+        return btc_info_5m
+
+    # BTC Indicator Switch Case
+    # ---------------------------------------------------------------------------------------------
+    def btc_info_switcher(self, btc_info_pair, btc_info_timeframe, metadata: dict) -> DataFrame:
+        if btc_info_timeframe == '1d':
+            return self.btc_info_1d_indicators(btc_info_pair, btc_info_timeframe, metadata)
+        elif btc_info_timeframe == '4h':
+            return self.btc_info_4h_indicators(btc_info_pair, btc_info_timeframe, metadata)
+        elif btc_info_timeframe == '1h':
+            return self.btc_info_1h_indicators(btc_info_pair, btc_info_timeframe, metadata)
+        elif btc_info_timeframe == '15m':
+            return self.btc_info_15m_indicators(btc_info_pair, btc_info_timeframe, metadata)
+        elif btc_info_timeframe == '5m':
+            return self.btc_info_5m_indicators(btc_info_pair, btc_info_timeframe, metadata)
+        else:
+            raise RuntimeError(f"{btc_info_timeframe} not supported as informative timeframe for BTC pair.")
+
+    def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
+        tik = time.perf_counter()
+        '''
+        --> BTC informative indicators
+        ___________________________________________________________________________________________
+        '''
+        if self.config['stake_currency'] in ['USDT','BUSD','USDC','DAI','TUSD','PAX','USD','EUR','GBP']:
+            btc_info_pair = f"BTC/{self.config['stake_currency']}"
+        else:
+            btc_info_pair = "BTC/USDT"
+
+        for btc_info_timeframe in self.btc_info_timeframes:
+            btc_informative = self.btc_info_switcher(btc_info_pair, btc_info_timeframe, metadata)
+            dataframe = merge_informative_pair(dataframe, btc_informative, self.timeframe, btc_info_timeframe, ffill=True)
+            # Customize what we drop - in case we need to maintain some BTC informative ohlcv data
+            # Default drop all
+            drop_columns = {
+                '1d':   [f"btc_{s}_{btc_info_timeframe}" for s in ['date', 'open', 'high', 'low', 'close', 'volume']],
+                '4h':   [f"btc_{s}_{btc_info_timeframe}" for s in ['date', 'open', 'high', 'low', 'close', 'volume']],
+                '1h':   [f"btc_{s}_{btc_info_timeframe}" for s in ['date', 'open', 'high', 'low', 'close', 'volume']],
+                '15m':  [f"btc_{s}_{btc_info_timeframe}" for s in ['date', 'open', 'high', 'low', 'close', 'volume']],
+                '5m':   [f"btc_{s}_{btc_info_timeframe}" for s in ['date', 'open', 'high', 'low', 'close', 'volume']],
+            }.get(btc_info_timeframe,[f"{s}_{btc_info_timeframe}" for s in ['date', 'open', 'high', 'low', 'close', 'volume']])
+            drop_columns.append(f"date_{btc_info_timeframe}")
+            dataframe.drop(columns=dataframe.columns.intersection(drop_columns), inplace=True)
+
+        '''
+        --> Indicators on informative timeframes
+        ___________________________________________________________________________________________
+        '''
+        for info_timeframe in self.info_timeframes:
+            info_indicators = self.info_switcher(metadata, info_timeframe)
+            dataframe = merge_informative_pair(dataframe, info_indicators, self.timeframe, info_timeframe, ffill=True)
+            # Customize what we drop - in case we need to maintain some informative timeframe ohlcv data
+            # Default drop all except base timeframe ohlcv data
+            drop_columns = {
+                '1d':   [f"{s}_{info_timeframe}" for s in ['date', 'open', 'high', 'low', 'close', 'volume']],
+                '4h':   [f"{s}_{info_timeframe}" for s in ['date', 'open', 'high', 'low', 'close', 'volume']],
+                '1h':   [f"{s}_{info_timeframe}" for s in ['date', 'open', 'high', 'low', 'close', 'volume']],
+                '15m':  [f"{s}_{info_timeframe}" for s in ['date', 'open', 'high', 'low', 'close', 'volume']]
+            }.get(info_timeframe,[f"{s}_{info_timeframe}" for s in ['date', 'open', 'high', 'low', 'close', 'volume']])
+            dataframe.drop(columns=dataframe.columns.intersection(drop_columns), inplace=True)
+
+        '''
+        --> The indicators for the base timeframe  (5m)
+        ___________________________________________________________________________________________
+        '''
+        dataframe = self.base_tf_5m_indicators(metadata, dataframe)
+
+        tok = time.perf_counter()
+        log.debug(f"[{metadata['pair']}] Populate indicators took a total of: {tok - tik:0.4f} seconds.")
+
+        return dataframe
+
+    def populate_buy_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
+        conditions = []
+        dataframe.loc[:, 'buy_tag'] = ''
+
+        for buy_enable in self.buy_params:
+            index = int(buy_enable.split('_')[2])
+            item_buy_protection_list = [True]
+            if self.buy_params[f'{buy_enable}']:
+
+                # Buy conditions
+                # -----------------------------------------------------------------------------------------
+                item_buy_logic = []
+                item_buy_logic.append(reduce(lambda x, y: x & y, item_buy_protection_list))
+
+                # Condition #1 - Long mode bull. Uptrend.
                 if index == 1:
                     # Protections
+                    item_buy_logic.append(dataframe['sma_50'] > dataframe['sma_200'])
+                    item_buy_logic.append(dataframe['sma_50_1h'] > dataframe['sma_200_1h'])
 
                     # Logic
                     item_buy_logic.append(dataframe['rsi_14'] < 30.0)
