Timeframe
5m
Direction
Long Only
Stoploss
-15.0%
Trailing Stop
No
ROI
0m: 1000.0%
Interface Version
2
Startup Candles
400
Indicators
24
freqtrade/freqtrade-strategies
Strategy 003 author@: Gerald Lonlas github@: https://github.com/freqtrade/freqtrade-strategies
# THIS STRATEGY IS PRIVATE. DO NOT SHARE.
# Heavily borrowed code from MultiMA_TSL3, ClucHAnix_BB_RPB.
# Big thanks to all the giants whose shoulders this strat is standing on:
# @stash86
# @Al
# @Rallipanos
# @pluxury
from logging import FATAL
from freqtrade.strategy.interface import IStrategy
from typing import Dict, List
from functools import reduce
from pandas import DataFrame, Series
import pandas_ta as pta
import talib.abstract as ta
import numpy as np
import freqtrade.vendor.qtpylib.indicators as qtpylib
import datetime
from technical.util import resample_to_interval, resampled_merge
from datetime import datetime, timedelta
from freqtrade.persistence import Trade
from freqtrade.strategy import stoploss_from_open, merge_informative_pair, DecimalParameter, IntParameter, \
CategoricalParameter, BooleanParameter
from freqtrade.exchange import timeframe_to_minutes
import technical.indicators as ftt
from technical.indicators import zema
# Buy hyperspace params:
buy_params = {
"base_nb_candles_buy": 17,
"ewo_high": 3.33,
"ewo_high_2": -0.444,
"ewo_low": -12.788,
"lookback_candles": 1,
"low_offset": 0.985,
"low_offset_2": 0.935,
"profit_threshold": 1.016,
"clucha_rocr_1h": 0.47782,
"clucha_bbdelta_close": 0.02206,
"clucha_bbdelta_tail": 1.02515,
"clucha_close_bblower": 0.03669,
"clucha_closedelta_close": 0.04401,
"base_nb_candles_buy_zema": 25,
"base_nb_candles_buy_zema2": 53,
"low_offset_zema": 0.958,
"low_offset_zema2": 0.961,
"base_nb_candles_buy_ema": 9,
"base_nb_candles_buy_ema2": 75,
"low_offset_ema": 1.067,
"low_offset_ema2": 0.973,
"high_offset_sell_ema": 0.994,
"rsi_buy": 71,
"max_change_pump": 35,
"cofi_adx": 8,
"cofi_ema": 0.639,
"cofi_enabled": False,
"cofi_ewo_high": 5.6,
"cofi_fastd": 40,
"cofi_fastk": 13,
"nfi32_cti_limit": -1.09639,
"nfi32_enabled": True,
"nfi32_rsi_14": 15,
"nfi32_rsi_4": 49,
"nfi32_sma_factor": 0.93391,
"ewo1_enabled": True,
"ewo2_enabled": True,
"ewolow_enabled": True,
"clucha_enabled": True,
"zema_enabled": True,
"vwma_enabled": True,
"base_nb_candles_buy_vwma": 26,
"base_nb_candles_buy_vwma2": 16,
"low_offset_vwma": 0.949,
"low_offset_vwma2": 0.951,
"vwap_enabled": True,
"ewo3_enabled": True,
"nfi24_enabled": True,
"keltner_enabled": True,
"gumbo_enabled": True,
"buy_gumbo_ema": 1.121,
"buy_gumbo_ewo_low": -9.442,
"buy_gumbo_cti": -0.374,
"buy_gumbo_r14": -51.971,
"nfix_39_enabled": True,
"buy_nfix_39_ema": 0.912,
"nfi7_33_enabled": True,
"nfi_38_enabled": True,
}
# Sell hyperspace params:
sell_params = {
"base_nb_candles_sell": 8,
"high_offset": 1.01,
"high_offset_2": 1.406,
"ProfitLoss1": 0.005,
"ProfitLoss2": 0.021,
"ProfitMargin1": 0.018,
"ProfitMargin2": 0.051,
"pHSL": -0.15,
}
# Protection hyperspace params:
protection_params = {
"low_profit_lookback": 48,
"low_profit_min_req": 0.04,
"low_profit_stop_duration": 14,
"cooldown_lookback": 2, # value loaded from strategy
"stoploss_lookback": 72, # value loaded from strategy
"stoploss_stop_duration": 20, # value loaded from strategy
}
class NASOSRv6_private_Reinuvader_20211121(IStrategy):
INTERFACE_VERSION = 2
# ROI table:
minimal_roi = {
"0": 10
}
# Stoploss:
stoploss = -0.15
# SMAOffset
base_nb_candles_buy = IntParameter(2, 26, default=buy_params['base_nb_candles_buy'], space='buy', optimize=True)
base_nb_candles_sell = IntParameter(2, 20, default=sell_params['base_nb_candles_sell'], space='sell',
optimize=True)
low_offset = DecimalParameter(0.85, 0.99, default=buy_params['low_offset'], space='buy', optimize=True)
low_offset_2 = DecimalParameter(0.9, 0.99, default=buy_params['low_offset_2'], space='buy', optimize=True)
high_offset = DecimalParameter(0.95, 1.1, default=sell_params['high_offset'], space='sell', optimize=True)
high_offset_2 = DecimalParameter(0.99, 1.5, default=sell_params['high_offset_2'], space='sell', optimize=True)
# Protection
fast_ewo = 50
slow_ewo = 200
cooldown_lookback = IntParameter(2, 48, default=protection_params['cooldown_lookback'], space="protection",
optimize=True)
low_profit_optimize = True
low_profit_lookback = IntParameter(2, 60, default=protection_params['low_profit_lookback'], space="protection",
optimize=low_profit_optimize)
low_profit_stop_duration = IntParameter(12, 200, default=protection_params['low_profit_stop_duration'],
space="protection", optimize=low_profit_optimize)
low_profit_min_req = DecimalParameter(-0.05, 0.05, default=protection_params['low_profit_min_req'],
space="protection", decimals=2,
optimize=low_profit_optimize)
lookback_candles = IntParameter(1, 36, default=buy_params['lookback_candles'], space='buy', optimize=True)
profit_threshold = DecimalParameter(1.0, 1.08, default=buy_params['profit_threshold'], space='buy', optimize=True)
ewo_low = DecimalParameter(-20.0, -8.0, default=buy_params['ewo_low'], space='buy', optimize=True)
ewo_high = DecimalParameter(2.0, 12.0, default=buy_params['ewo_high'], space='buy', optimize=True)
ewo_high_2 = DecimalParameter(-6.0, 12.0, default=buy_params['ewo_high_2'], space='buy', optimize=True)
rsi_buy = IntParameter(60, 82, default=buy_params['rsi_buy'], space='buy', optimize=True)
# trailing stoploss hyperopt parameters
pHSL = DecimalParameter(-0.15, -0.08, default=sell_params['pHSL'], decimals=3, space='sell', optimize=True)
ProfitMargin1 = DecimalParameter(0.009, 0.019, default=sell_params['ProfitMargin1'], decimals=3, space='sell',
optimize=True)
ProfitLoss1 = DecimalParameter(0.005, 0.012, default=sell_params['ProfitLoss1'], decimals=3, space='sell',
optimize=True)
ProfitMargin2 = DecimalParameter(0.033, 0.099, default=sell_params['ProfitMargin2'], decimals=3, space='sell',
optimize=True)
ProfitLoss2 = DecimalParameter(0.010, 0.025, default=sell_params['ProfitLoss2'], decimals=3, space='sell',
optimize=True)
# ClucHA
clucha_bbdelta_close = DecimalParameter(0.01, 0.05, default=buy_params['clucha_bbdelta_close'], decimals=5,
space='buy', optimize=True)
clucha_bbdelta_tail = DecimalParameter(0.7, 1.2, default=buy_params['clucha_bbdelta_tail'], decimals=5, space='buy',
optimize=True)
clucha_close_bblower = DecimalParameter(0.001, 0.05, default=buy_params['clucha_close_bblower'], decimals=5,
space='buy', optimize=True)
clucha_closedelta_close = DecimalParameter(0.001, 0.05, default=buy_params['clucha_closedelta_close'], decimals=5,
space='buy', optimize=True)
clucha_rocr_1h = DecimalParameter(0.1, 1.0, default=buy_params['clucha_rocr_1h'], decimals=5, space='buy',
optimize=True)
# Zema
base_nb_candles_buy_zema = IntParameter(5, 80, default=buy_params['base_nb_candles_buy_zema'], space='buy',
optimize=True)
low_offset_zema = DecimalParameter(0.9, 0.99, default=buy_params['low_offset_zema'], space='buy', optimize=True)
base_nb_candles_buy_zema2 = IntParameter(5, 80, default=buy_params['base_nb_candles_buy_zema2'], space='buy',
optimize=True)
low_offset_zema2 = DecimalParameter(0.9, 0.99, default=buy_params['low_offset_zema2'], space='buy', optimize=True)
high_offset_sell_ema = DecimalParameter(0.99, 1.1, default=buy_params['high_offset_sell_ema'], space='buy',
optimize=True)
base_nb_candles_buy_ema = IntParameter(5, 80, default=buy_params['base_nb_candles_buy_ema'], space='buy',
optimize=True)
low_offset_ema = DecimalParameter(0.9, 1.1, default=buy_params['low_offset_ema'], space='buy', optimize=True)
base_nb_candles_buy_ema2 = IntParameter(5, 80, default=buy_params['base_nb_candles_buy_ema2'], space='buy',
optimize=True)
low_offset_ema2 = DecimalParameter(0.9, 1.1, default=buy_params['low_offset_ema2'], space='buy', optimize=True)
max_change_pump = IntParameter(10, 50, default=buy_params['max_change_pump'], space='buy', optimize=True)
# cofi
cofi_ema = DecimalParameter(0.6, 1.4, default=buy_params['cofi_ema'], space='buy', optimize=True)
cofi_fastk = IntParameter(1, 100, default=buy_params['cofi_fastk'], space='buy', optimize=True)
cofi_fastd = IntParameter(1, 100, default=buy_params['cofi_fastd'], space='buy', optimize=True)
cofi_adx = IntParameter(1, 100, default=buy_params['cofi_adx'], space='buy', optimize=True)
cofi_ewo_high = DecimalParameter(1.0, 15.0, default=buy_params['cofi_ewo_high'], space='buy', optimize=True)
cofi_enabled = BooleanParameter(default=buy_params['cofi_enabled'], space='buy', optimize=True)
# nfi32
nfi32_rsi_4 = IntParameter(1, 100, default=buy_params['nfi32_rsi_4'], space='buy', optimize=True)
nfi32_rsi_14 = IntParameter(1, 100, default=buy_params['nfi32_rsi_14'], space='buy', optimize=True)
nfi32_sma_factor = DecimalParameter(0.7, 1.2, default=buy_params['nfi32_sma_factor'], decimals=5, space='buy',
optimize=True)
nfi32_cti_limit = DecimalParameter(-1.2, 0, default=buy_params['nfi32_cti_limit'], decimals=5, space='buy',
optimize=True)
nfi32_enabled = BooleanParameter(default=buy_params['nfi32_enabled'], space='buy', optimize=True)
ewo1_enabled = BooleanParameter(default=buy_params['ewo1_enabled'], space='buy', optimize=True)
ewo2_enabled = BooleanParameter(default=buy_params['ewo2_enabled'], space='buy', optimize=True)
ewolow_enabled = BooleanParameter(default=buy_params['ewolow_enabled'], space='buy', optimize=True)
clucha_enabled = BooleanParameter(default=buy_params['clucha_enabled'], space='buy', optimize=True)
zema_enabled = BooleanParameter(default=buy_params['zema_enabled'], space='buy', optimize=True)
vwma_enabled = BooleanParameter(default=buy_params['vwma_enabled'], space='buy', optimize=True)
optimize_buy_vwma = True
base_nb_candles_buy_vwma = IntParameter(5, 80, default=buy_params['base_nb_candles_buy_vwma'], space='buy',
optimize=optimize_buy_vwma)
low_offset_vwma = DecimalParameter(0.9, 0.99, default=buy_params['low_offset_vwma'], space='buy',
optimize=optimize_buy_vwma)
base_nb_candles_buy_vwma2 = IntParameter(5, 80, default=buy_params['base_nb_candles_buy_vwma2'], space='buy',
optimize=optimize_buy_vwma)
low_offset_vwma2 = DecimalParameter(0.9, 0.99, default=buy_params['low_offset_vwma2'], space='buy',
optimize=optimize_buy_vwma)
vwap_enabled = BooleanParameter(default=buy_params['vwap_enabled'], space='buy', optimize=True)
ewo3_enabled = BooleanParameter(default=buy_params['ewo3_enabled'], space='buy', optimize=True)
# nfi24
nfi24_enabled = BooleanParameter(default=buy_params['nfi24_enabled'], space='buy', optimize=True)
buy_24_rsi_14_max = 50.0
buy_24_rsi_14_1h_min = 66.9
# keltner channel
keltner_enabled = BooleanParameter(default=buy_params['keltner_enabled'], space='buy', optimize=True)
# gumbo
is_optimize_gumbo = True
gumbo_enabled = BooleanParameter(default=buy_params['gumbo_enabled'], space='buy', optimize=True)
buy_gumbo_ema = DecimalParameter(0.9, 1.2, default=0.97, optimize=is_optimize_gumbo)
buy_gumbo_ewo_low = DecimalParameter(-12.0, 5, default=-5.585, optimize=is_optimize_gumbo)
is_optimize_gumbo_protection = True
buy_gumbo_cti = DecimalParameter(-0.9, -0.0, default=-0.5, optimize=is_optimize_gumbo_protection)
buy_gumbo_r14 = DecimalParameter(-100, -44, default=-60, optimize=is_optimize_gumbo_protection)
# nfix_39
nfix_39_enabled = BooleanParameter(default=buy_params['nfix_39_enabled'], space='buy', optimize=True)
buy_nfix_39_ema = DecimalParameter(0.9, 1.2, default=0.97, optimize=True)
# nfi7_33
nfi7_33_enabled = BooleanParameter(default=buy_params['nfi7_33_enabled'], space='buy', optimize=True)
# nfi_38
nfi_38_enabled = BooleanParameter(default=buy_params['nfi_38_enabled'], space='buy', optimize=True)
# Trailing stop:
trailing_stop = False
# trailing_stop_positive = 0.001
# trailing_stop_positive_offset = 0.016
# trailing_only_offset_is_reached = True
# Sell signal
use_sell_signal = True
# sell_profit_only = False
# sell_profit_offset = -0.0001
# ignore_roi_if_buy_signal = False
# Optional order time in force.
order_time_in_force = {
'buy': 'gtc',
'sell': 'gtc'
}
# Optimal timeframe for the strategy
timeframe = '5m'
inf_1h = '1h'
timeframe_minutes = timeframe_to_minutes(timeframe)
timeperiods = [
# 50 // timeframe_minutes,
# 85 // timeframe_minutes,
180 // timeframe_minutes,
360 // timeframe_minutes,
420 // timeframe_minutes,
560 // timeframe_minutes,
]
process_only_new_candles = True
startup_candle_count = 400
use_custom_stoploss = True
plot_config = {
'main_plot': {
'ma_buy': {'color': 'orange'},
'ma_sell': {'color': 'orange'},
},
}
slippage_protection = {
'retries': 3,
'max_slippage': -0.02
}
@property
def protections(self):
prot = []
prot.append({
"method": "CooldownPeriod",
"stop_duration_candles": self.cooldown_lookback.value
})
prot.append({
"method": "LowProfitPairs",
"lookback_period_candles": self.low_profit_lookback.value,
"trade_limit": 1,
"stop_duration": int(self.low_profit_stop_duration.value),
"required_profit": self.low_profit_min_req.value
})
return prot
def custom_sell(self, pair: str, trade: 'Trade', current_time: 'datetime', current_rate: float,
current_profit: float, **kwargs):
dataframe, _ = self.dp.get_analyzed_dataframe(pair, self.timeframe)
last_candle = dataframe.iloc[-1]
if ((current_time - trade.open_date_utc).seconds / 60 > 1440):
return 'unclog'
# main sell
if current_profit > 0.02:
if (last_candle['momdiv_sell_1h'] == True):
return f"signal_profit_q_momdiv_1h"
if (last_candle['momdiv_sell'] == True):
return f"signal_profit_q_momdiv"
if (last_candle['momdiv_coh'] == True):
return f"signal_profit_q_momdiv_coh"
def custom_stoploss(self, pair: str, trade: 'Trade', current_time: datetime,
current_rate: float, current_profit: float, **kwargs) -> float:
HSL = self.pHSL.value
if (current_profit > self.ProfitMargin2.value):
sl_profit = self.ProfitLoss2.value
elif (current_profit > self.ProfitMargin1.value):
sl_profit = self.ProfitLoss1.value + ((current_profit - self.ProfitMargin1.value) * (
self.ProfitLoss2.value - self.ProfitLoss1.value) / (
self.ProfitMargin2.value - self.ProfitMargin1.value))
else:
sl_profit = HSL
return sl_profit
def confirm_trade_exit(self, pair: str, trade: Trade, order_type: str, amount: float,
rate: float, time_in_force: str, sell_reason: str,
current_time: datetime, **kwargs) -> bool:
dataframe, _ = self.dp.get_analyzed_dataframe(pair, self.timeframe)
last_candle = dataframe.iloc[-1]
if (last_candle is not None):
if (sell_reason in ['sell_signal']):
if (last_candle['hma_50'] * 1.149 > last_candle['ema_100']) and (
last_candle['close'] < last_candle['ema_100'] * 0.951): # *1.2
return False
# slippage
try:
state = self.slippage_protection['__pair_retries']
except KeyError:
state = self.slippage_protection['__pair_retries'] = {}
candle = dataframe.iloc[-1].squeeze()
slippage = (rate / candle['close']) - 1
if slippage < self.slippage_protection['max_slippage']:
pair_retries = state.get(pair, 0)
if pair_retries < self.slippage_protection['retries']:
state[pair] = pair_retries + 1
return False
state[pair] = 0
if hasattr(last_candle, 'sell_tag') and str(last_candle.sell_tag) != "nan":
if (sell_reason == "sell_signal"):
sell_reason = last_candle.sell_tag
else:
sell_reason += last_candle.sell_tag
trade.sell_reason = f"{trade.buy_tag}->{sell_reason}"
return True
def informative_pairs(self):
pairs = self.dp.current_whitelist()
informative_pairs = [(pair, '1h') 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.append((btc_info_pair, self.timeframe))
return informative_pairs
def informative_1h_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
assert self.dp, "DataProvider is required for multiple timeframes."
# Get the informative pair
informative = self.dp.get_pair_dataframe(pair=metadata['pair'], timeframe=self.inf_1h)
inf_heikinashi = qtpylib.heikinashi(informative)
informative['ha_close'] = inf_heikinashi['close']
informative['rocr'] = ta.ROCR(informative['ha_close'], timeperiod=168)
informative['ema_12'] = ta.EMA(informative, timeperiod=12)
informative['ema_35'] = ta.EMA(informative, timeperiod=35)
informative['rsi_14'] = ta.RSI(informative, timeperiod=14)
informative['cmf'] = chaikin_money_flow(informative, 20)
bollinger2 = qtpylib.bollinger_bands(qtpylib.typical_price(informative), window=20, stds=2)
informative['bb_lowerband2'] = bollinger2['lower']
informative['bb_middleband2'] = bollinger2['mid']
informative['bb_upperband2'] = bollinger2['upper']
informative['bb_width'] = (
(informative['bb_upperband2'] - informative['bb_lowerband2']) / informative[
'bb_middleband2'])
informative['T3'] = T3(informative)
informative['ema_200'] = ta.EMA(informative, timeperiod=200)
# CRSI (3, 2, 100)
crsi_closechange = informative['close'] / informative['close'].shift(1)
crsi_updown = np.where(crsi_closechange.gt(1), 1.0, np.where(crsi_closechange.lt(1), -1.0, 0.0))
informative['crsi'] = (ta.RSI(informative['close'], timeperiod=3) + ta.RSI(crsi_updown,
timeperiod=2) + ta.ROC(
informative['close'], 100)) / 3
# MOMDIV
mom = momdiv(informative)
informative['momdiv_buy'] = mom['momdiv_buy']
informative['momdiv_sell'] = mom['momdiv_sell']
informative['momdiv_coh'] = mom['momdiv_coh']
informative['momdiv_col'] = mom['momdiv_col']
return informative
def top_percent_change(self, dataframe: DataFrame, length: int) -> float:
"""
Percentage change of the current close from the range maximum Open price
:param dataframe: DataFrame The original OHLC dataframe
:param length: int The length to look back
"""
df = dataframe.copy()
if length == 0:
return ((df['open'] - df['close']) / df['close'])
else:
return ((df['open'].rolling(length).max() - df['close']) / df['close'])
def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
informative_1h = self.informative_1h_indicators(dataframe, metadata)
dataframe = merge_informative_pair(dataframe, informative_1h, self.timeframe, self.inf_1h, ffill=True)
# The indicators for the normal (5m) timeframe
dataframe = self.normal_tf_indicators(dataframe, metadata)
return dataframe
def normal_tf_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
df36h = dataframe.copy().shift(432) # TODO FIXME: This assumes 5m timeframe
df24h = dataframe.copy().shift(288) # TODO FIXME: This assumes 5m timeframe
dataframe['long_term_price_warning'] = np.where(
(
# 15% drop in 8h
(
dataframe['close'].rolling(96).max() * 0.85 > dataframe['close'].rolling(6).mean()
) |
# 20% drop in 12h
(
dataframe['close'].rolling(144).max() * 0.8 > dataframe['close'].rolling(8).mean()
) |
# 25% drop in 24h
(
dataframe['close'].rolling(288).max() * 0.75 > dataframe['close'].rolling(12).mean()
) |
# 30% drop in 36h
(
dataframe['close'].rolling(432).max() * 0.7 > dataframe['close'].rolling(24).mean()
) |
# over 35% increase in the past 24h and 36h
(
(df24h['close'].rolling(24).mean() * 1.42 < dataframe['close'].rolling(18).mean()) &
(df36h['close'].rolling(24).mean() * 1.42 < dataframe['close'].rolling(18).mean())
)
), 1, 0)
for period in self.timeperiods:
dataframe[f'rsi_{period}'] = normalize(ta.RSI(dataframe, timeperiod=period), 0, 100)
dataframe[f'linangle_{period}'] = normalize(ta.LINEARREG_ANGLE(dataframe, timeperiod=period), -35, 35)
# MACD
dataframe['close_min'] = dataframe['close'].rolling(window=960 // self.timeframe_minutes).min()
dataframe['close_max'] = dataframe['close'].rolling(window=960 // self.timeframe_minutes).max()
dataframe['relative_price'] = normalize(dataframe['close'], dataframe['close_min'], dataframe['close_max'])
# macd = ta.MACD(dataframe)
dataframe['macd'], dataframe['macdsignal'], dataframe['macdhist'] = ta.MACD(dataframe['close'], fastperiod=21,
slowperiod=45, signalperiod=16)
dataframe['macdmin'] = dataframe['macd'].rolling(window=360 // self.timeframe_minutes).min()
dataframe['macdmax'] = dataframe['macd'].rolling(window=360 // self.timeframe_minutes).max()
dataframe['macd_norm'] = np.where(dataframe['macdmin'] == dataframe['macdmax'], 0, (
2.0 * (dataframe['macd'] - dataframe['macdmin']) / (
dataframe['macdmax'] - dataframe['macdmin']) - 1.0))
# Calculate all ma_buy values
for val in self.base_nb_candles_buy.range:
dataframe[f'ma_buy_{val}'] = ta.EMA(dataframe, timeperiod=val)
# Calculate all ma_sell values
for val in self.base_nb_candles_sell.range:
dataframe[f'ma_sell_{val}'] = ta.EMA(dataframe, timeperiod=val)
dataframe['hma_50'] = qtpylib.hull_moving_average(dataframe['close'], window=50)
dataframe['ema_100'] = ta.EMA(dataframe, timeperiod=100)
dataframe['ema_8'] = ta.EMA(dataframe, timeperiod=8)
dataframe['sma_9'] = ta.SMA(dataframe, timeperiod=9)
# Elliot
dataframe['EWO'] = EWO(dataframe, self.fast_ewo, self.slow_ewo)
# RSI
dataframe['rsi'] = ta.RSI(dataframe, timeperiod=14)
dataframe['rsi_fast'] = ta.RSI(dataframe, timeperiod=4)
dataframe['rsi_slow'] = ta.RSI(dataframe, timeperiod=20)
dataframe['ema_fast'] = ta.EMA(dataframe, timeperiod=45 // self.timeframe_minutes)
dataframe['ema_slow'] = ta.EMA(dataframe, timeperiod=60 // self.timeframe_minutes)
dataframe['uptrend'] = (dataframe['ema_fast'] > dataframe['ema_slow']).astype('int')
dataframe['trendline'] = dataframe['linangle_72'] / dataframe['linangle_72'].shift(12)
# Heikin Ashi Candles
heikinashi = qtpylib.heikinashi(dataframe)
dataframe['ha_close'] = heikinashi['close']
dataframe['ha_high'] = heikinashi['high']
dataframe['ha_low'] = heikinashi['low']
# Profit Maximizer - PMAX
dataframe['pm'], dataframe['pmx'] = pmax(heikinashi, MAtype=1, length=9, multiplier=27, period=10, src=3)
dataframe['source'] = (dataframe['high'] + dataframe['low'] + dataframe['open'] + dataframe['close']) / 4
dataframe['pmax_thresh'] = ta.EMA(dataframe['source'], timeperiod=9)
dataframe = HA(dataframe, 4)
# Set Up Bollinger Bands
mid, lower = bollinger_bands(ha_typical_price(dataframe), window_size=40, num_of_std=2)
dataframe['lower'] = lower
dataframe['mid'] = mid
# # ClucHA
dataframe['bbdelta'] = (mid - dataframe['lower']).abs()
dataframe['ha_closedelta'] = (dataframe['ha_close'] - dataframe['ha_close'].shift()).abs()
dataframe['tail'] = (dataframe['ha_close'] - dataframe['ha_low']).abs()
dataframe['hema_slow'] = ta.EMA(dataframe['ha_close'], timeperiod=50)
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"
btc_df = self.dp.get_pair_dataframe(pair=btc_info_pair, timeframe=self.timeframe)
dataframe['btc_rsi'] = normalize(ta.RSI(btc_df, timeperiod=14), 0, 100)
dataframe['btc_ema_45'] = ta.TEMA(btc_df, timeperiod=45 // self.timeframe_minutes)
dataframe['btc_ema_60'] = ta.TEMA(btc_df, timeperiod=60 // self.timeframe_minutes)
dataframe['btc_uptrend'] = (dataframe['btc_ema_45'] > dataframe['btc_ema_60']).astype('int')
dataframe['zema_offset_buy'] = zema(dataframe,
int(self.base_nb_candles_buy_zema.value)) * self.low_offset_zema.value
dataframe['zema_offset_buy2'] = zema(dataframe,
int(self.base_nb_candles_buy_zema2.value)) * self.low_offset_zema2.value
dataframe['ema_sell'] = ta.EMA(dataframe, 5)
dataframe['ema_offset_buy'] = ta.EMA(dataframe,
int(self.base_nb_candles_buy_ema.value)) * self.low_offset_ema.value
dataframe['ema_offset_buy2'] = ta.EMA(dataframe,
int(self.base_nb_candles_buy_ema2.value)) * self.low_offset_ema2.value
# pump detector
dataframe['pump'] = pump_warning(dataframe, perc=int(self.max_change_pump.value))
# Cofi
stoch_fast = ta.STOCHF(dataframe, 5, 3, 0, 3, 0)
dataframe['fastd'] = stoch_fast['fastd']
dataframe['fastk'] = stoch_fast['fastk']
dataframe['adx'] = ta.ADX(dataframe)
dataframe['rsi_4'] = ta.RSI(dataframe, timeperiod=4)
dataframe['rsi_14'] = ta.RSI(dataframe, timeperiod=14)
dataframe['rsi_20'] = ta.RSI(dataframe, timeperiod=20)
dataframe['rsi_36'] = ta.RSI(dataframe, timeperiod=36)
dataframe['rsi_84'] = ta.RSI(dataframe, timeperiod=84)
dataframe['rsi_112'] = ta.RSI(dataframe, timeperiod=112)
dataframe['sma_15'] = ta.SMA(dataframe, timeperiod=15)
# CTI
dataframe['cti'] = pta.cti(dataframe["close"], length=20)
# vwap
vwap_low, vwap, vwap_high = VWAPB(dataframe, 20, 1)
dataframe['vwap_low'] = vwap_low
dataframe['tcp_percent_4'] = self.top_percent_change(dataframe, 4)
# TEMA - Triple Exponential Moving Average
dataframe['tema'] = ta.TEMA(dataframe, timeperiod=9)
dataframe['cci'] = ta.CCI(dataframe, 26)
# CMF
dataframe['cmf'] = chaikin_money_flow(dataframe, 20)
# keltner
keltner = qtpylib.keltner_channel(dataframe, window=20, atrs=1)
dataframe["kc_upperband"] = keltner["upper"]
dataframe["kc_lowerband"] = keltner["lower"]
dataframe["kc_middleband"] = keltner["mid"]
# Horizontal RSI line
hline = 55
dataframe['hline'] = hline
# Williams %R
dataframe['r_14'] = williams_r(dataframe, period=14)
dataframe['r_32'] = williams_r(dataframe, period=32)
dataframe['r_64'] = williams_r(dataframe, period=64)
dataframe['r_96'] = williams_r(dataframe, period=96)
dataframe['r_480'] = williams_r(dataframe, period=480)
# T3
dataframe['T3'] = T3(dataframe)
## BB 40
bollinger2_40 = qtpylib.bollinger_bands(ha_typical_price(dataframe), window=40, stds=2)
dataframe['bb_lowerband2_40'] = bollinger2_40['lower']
dataframe['bb_middleband2_40'] = bollinger2_40['mid']
dataframe['bb_upperband2_40'] = bollinger2_40['upper']
dataframe['bb_delta_cluc'] = (dataframe['bb_middleband2_40'] - dataframe['bb_lowerband2_40']).abs()
dataframe['closedelta'] = (dataframe['close'] - dataframe['close'].shift()).abs()
dataframe['ema_13'] = ta.EMA(dataframe, timeperiod=13)
# Modified Elder Ray Index
dataframe['moderi_96'] = moderi(dataframe, 96)
# Volume
dataframe['volume_mean_4'] = dataframe['volume'].rolling(4).mean().shift(1)
dataframe['volume_mean_12'] = dataframe['volume'].rolling(12).mean().shift(1)
dataframe['volume_mean_24'] = dataframe['volume'].rolling(24).mean().shift(1)
# SMA
dataframe['sma_9'] = ta.SMA(dataframe, timeperiod=9)
dataframe['sma_15'] = ta.SMA(dataframe, timeperiod=15)
dataframe['sma_20'] = ta.SMA(dataframe, timeperiod=20)
dataframe['sma_21'] = ta.SMA(dataframe, timeperiod=21)
dataframe['sma_28'] = ta.SMA(dataframe, timeperiod=28)
dataframe['sma_30'] = ta.SMA(dataframe, timeperiod=30)
dataframe['sma_75'] = ta.SMA(dataframe, timeperiod=75)
# MOMDIV
mom = momdiv(dataframe)
dataframe['momdiv_buy'] = mom['momdiv_buy']
dataframe['momdiv_sell'] = mom['momdiv_sell']
dataframe['momdiv_coh'] = mom['momdiv_coh']
dataframe['momdiv_col'] = mom['momdiv_col']
return dataframe
def populate_buy_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
dont_buy_conditions = []
dont_buy_conditions.append(
(
# don't buy if there isn't some profit to be made
(dataframe['close_1h'].rolling(self.lookback_candles.value).max()
< (dataframe['close'] * self.profit_threshold.value))
)
)
dont_buy_conditions.append((dataframe['trendline'] < 0.995))
dont_buy_conditions.append((dataframe['relative_price'] > 0.51))
# if there's a pump, don't buy
dont_buy_conditions.append(dataframe['pump'].rolling(20).max() >= 1)
dataframe.loc[
(
bool(self.ewo1_enabled.value) &
(dataframe['rsi_fast'] < 35) &
(dataframe['rsi_36'] < 0.45) &
(dataframe['close'] < (
dataframe[f'ma_buy_{self.base_nb_candles_buy.value}'] * self.low_offset.value)) &
(dataframe['EWO'] > self.ewo_high.value) &
(dataframe['rsi'] < self.rsi_buy.value) &
(dataframe['volume'] > 0) &
(dataframe['close'] < (
dataframe[f'ma_sell_{self.base_nb_candles_sell.value}'] * self.high_offset.value))
),
['buy', 'buy_tag']] = (1, 'ewo1')
dataframe.loc[
(
bool(self.ewo2_enabled.value) &
(dataframe['rsi_fast'] < 35) &
(dataframe['close'] < (
dataframe[f'ma_buy_{self.base_nb_candles_buy.value}'] * self.low_offset_2.value)) &
(dataframe['EWO'] > self.ewo_high_2.value) &
(dataframe['rsi'] < self.rsi_buy.value) &
(dataframe['volume'] > 0) &
(dataframe['close'] < (
dataframe[f'ma_sell_{self.base_nb_candles_sell.value}'] * self.high_offset.value)) &
(dataframe['rsi'] < 25)
),
['buy', 'buy_tag']] = (1, 'ewo2')
dataframe.loc[
(
bool(self.ewolow_enabled.value) &
(dataframe['rsi_fast'] < 35) &
(dataframe['close'] < (
dataframe[f'ma_buy_{self.base_nb_candles_buy.value}'] * self.low_offset.value)) &
(dataframe['EWO'] < self.ewo_low.value) &
(dataframe['volume'] > 0) &
(dataframe['close'] < (
dataframe[f'ma_sell_{self.base_nb_candles_sell.value}'] * self.high_offset.value))
),
['buy', 'buy_tag']] = (1, 'ewolow')
# This produces around 0.85% - 1.0% profitable trades but long durations so decided against it.
# dataframe.loc[
# (
# (
# (
# (dataframe['macd_norm'] < -0.9) &
# (dataframe['linangle_17'] > 0.5)
# )
# ) &
# (dataframe['rsi_36'] < 0.55) &
# (dataframe['uptrend'] < 1)
# ),
# ['buy', 'buy_tag']] = (1, 'MacD')
if dont_buy_conditions:
for condition in dont_buy_conditions:
dataframe.loc[condition, 'buy'] = 0
# This does not fit well the protections for EWO buys.
dataframe.loc[
(
bool(self.clucha_enabled.value) &
(dataframe['volume'] > 0) &
(dataframe['rocr_1h'].gt(self.clucha_rocr_1h.value)) &
(
(
(dataframe['lower'].shift().gt(0)) &
(dataframe['bbdelta'].gt(dataframe['ha_close'] * self.clucha_bbdelta_close.value)) &
(dataframe['ha_closedelta'].gt(
dataframe['ha_close'] * self.clucha_closedelta_close.value)) &
(dataframe['tail'].lt(dataframe['bbdelta'] * self.clucha_bbdelta_tail.value)) &
(dataframe['ha_close'].lt(dataframe['lower'].shift())) &
(dataframe['ha_close'].le(dataframe['ha_close'].shift()))
) |
(
(dataframe['ha_close'] < dataframe['hema_slow']) &
(dataframe['ha_close'] < self.clucha_close_bblower.value * dataframe['lower'])
)
)
),
['buy', 'buy_tag']] = (1, 'clucHA')
# This does not fit well the protections for EWO buys.
dataframe.loc[
(
bool(self.zema_enabled.value) &
(
((dataframe['close'] < dataframe['zema_offset_buy']) & (
dataframe['pm'] <= dataframe['pmax_thresh'])) |
((dataframe['close'] < dataframe['zema_offset_buy2']) & (
dataframe['pm'] > dataframe['pmax_thresh']))
) &
(dataframe['volume'] > 0) &
(dataframe['long_term_price_warning'] < 1) &
(dataframe['trendline'] > 0.996) &
(dataframe['btc_rsi'] > 0.49) &
(dataframe['close'] < dataframe['Smooth_HA_L']) &
(dataframe['close'] < (dataframe['ema_sell'] * self.high_offset_sell_ema.value)) &
(dataframe['close'].rolling(288).max() >= (dataframe['close'] * 1.10)) &
(dataframe['Smooth_HA_O'].shift(1) < dataframe['Smooth_HA_H'].shift(1)) &
(dataframe['rsi_fast'] < 35) &
(dataframe['rsi_84'] < 60) &
(dataframe['rsi_112'] < 60) &
(
(
(dataframe['close'] < dataframe['ema_offset_buy']) &
(dataframe['pm'] <= dataframe['pmax_thresh']) &
(
(dataframe['EWO'] < -19.632) |
(
(dataframe['EWO'] > 2.615) & (dataframe['rsi'] < 60)
)
)
) |
(
(dataframe['close'] < dataframe['ema_offset_buy2']) &
(dataframe['pm'] > dataframe['pmax_thresh']) &
(
(dataframe['EWO'] < -19.955) |
(
(dataframe['EWO'] > 2.188) & (dataframe['rsi'] < 45)
)
)
)
)
),
['buy', 'buy_tag']] = (1, 'zema')
# cofi
cofi = (
bool(self.cofi_enabled.value) &
(dataframe['open'] < dataframe['ema_8'] * self.cofi_ema.value) &
(qtpylib.crossed_above(dataframe['fastk'], dataframe['fastd'])) &
(dataframe['fastk'] < self.cofi_fastk.value) &
(dataframe['fastd'] < self.cofi_fastd.value) &
(dataframe['adx'] > self.cofi_adx.value) &
(dataframe['EWO'] > self.cofi_ewo_high.value)
)
dataframe.loc[cofi, ['buy', 'buy_tag']] = (1, 'cofi')
# nfi
nfi_32 = (
bool(self.nfi32_enabled.value) &
(dataframe['rsi_20'] < dataframe['rsi_20'].shift(1)) &
(dataframe['rsi_4'] < self.nfi32_rsi_4.value) &
(dataframe['rsi_14'] > self.nfi32_rsi_14.value) &
(dataframe['close'] < dataframe['sma_15'] * self.nfi32_sma_factor.value) &
(dataframe['cti'] < self.nfi32_cti_limit.value)
)
dataframe.loc[nfi_32, ['buy', 'buy_tag']] = (1, 'nfi32')
# vwma
dataframe['vwma_offset_buy'] = pta.vwma(dataframe["close"], dataframe["volume"],
int(self.base_nb_candles_buy_vwma.value)) * self.low_offset_vwma.value
dataframe['vwma_offset_buy2'] = pta.vwma(dataframe["close"], dataframe["volume"],
int(self.base_nb_candles_buy_vwma2.value)) * self.low_offset_vwma2.value
buy_offset_vwma = (
bool(self.vwma_enabled.value) &
(
(
(dataframe['close'] < dataframe['vwma_offset_buy'])
&
(dataframe['pm'] <= dataframe['pmax_thresh'])
)
|
(
(dataframe['close'] < dataframe['vwma_offset_buy2'])
&
(dataframe['pm'] > dataframe['pmax_thresh'])
)
)
)
dataframe.loc[buy_offset_vwma, ['buy', 'buy_tag']] = (1, 'vwma')
# vwap
buy_offset_vwap = (
bool(self.vwap_enabled.value) &
(dataframe['close'] < dataframe['vwap_low']) &
(dataframe['tcp_percent_4'] > 0.04) &
(dataframe['cti'] < -0.8) &
(dataframe['rsi'] < 35) &
(dataframe['rsi_84'] < 60) &
(dataframe['rsi_112'] < 60) &
(dataframe['volume'] > 0)
)
dataframe.loc[buy_offset_vwap, ['buy', 'buy_tag']] = (1, 'vwap')
# ewo3
ewo3 = (
bool(self.ewo3_enabled.value) &
(qtpylib.crossed_above(dataframe['rsi_fast'], dataframe['rsi_slow'])) &
(dataframe['open'] < dataframe['lower']) &
(dataframe['tema'] < dataframe['mid']) &
(dataframe['cci'] < -100) &
(
(dataframe['EWO'] < -19.993) |
(dataframe['EWO'] > 5.638)
) &
(dataframe['volume'] > 0)
)
dataframe.loc[ewo3, ['buy', 'buy_tag']] = (1, 'ewo3')
# nfi24
nfi24 = (
bool(self.nfi24_enabled.value) &
(dataframe['ema_12_1h'].shift(12) < dataframe['ema_35_1h'].shift(12)) &
(dataframe['ema_12_1h'] > dataframe['ema_35_1h']) &
(dataframe['cmf_1h'].shift(12) < 0) &
(dataframe['cmf_1h'] > 0) &
(dataframe['rsi_14'] < self.buy_24_rsi_14_max) &
(dataframe['rsi_14_1h'] > self.buy_24_rsi_14_1h_min)
)
dataframe.loc[nfi24, ['buy', 'buy_tag']] = (1, 'nfi24')
# keltner
keltner = (
bool(self.keltner_enabled.value) &
(qtpylib.crossed_above(dataframe['close'], dataframe['kc_upperband']))
& (dataframe["rsi"] > dataframe['hline'])
)
dataframe.loc[keltner, ['buy', 'buy_tag']] = (1, 'keltner')
# gumbo
gumbo = (
bool(self.gumbo_enabled.value) &
(dataframe['EWO'] < self.buy_gumbo_ewo_low.value) &
(dataframe['bb_middleband2_1h'] >= dataframe['T3_1h']) &
(dataframe['T3'] <= dataframe['ema_8'] * self.buy_gumbo_ema.value) &
(dataframe['cti'] < self.buy_gumbo_cti.value) &
(dataframe['r_14'] < self.buy_gumbo_r14.value)
)
dataframe.loc[gumbo, ['buy', 'buy_tag']] = (1, 'gumbo')
# nfix_39
nfix_39 = (
bool(self.nfix_39_enabled.value) &
(dataframe['ema_200_1h'] > dataframe['ema_200_1h'].shift(12)) &
(dataframe['ema_200_1h'].shift(12) > dataframe['ema_200_1h'].shift(24)) &
(dataframe['bb_lowerband2_40'].shift().gt(0)) &
(dataframe['bb_delta_cluc'].gt(dataframe['close'] * 0.056)) &
(dataframe['closedelta'].gt(dataframe['close'] * 0.01)) &
(dataframe['tail'].lt(dataframe['bb_delta_cluc'] * 0.5)) &
(dataframe['close'].lt(dataframe['bb_lowerband2_40'].shift())) &
(dataframe['close'].le(dataframe['close'].shift())) &
(dataframe['close'] > dataframe['ema_13'] * self.buy_nfix_39_ema.value)
)
dataframe.loc[nfix_39, ['buy', 'buy_tag']] = (1, 'nfix_39')
# nfi7_33
nfi7_33 = (
bool(self.nfi7_33_enabled.value) &
(dataframe['moderi_96']) &
(dataframe['cti'] < -0.88) &
(dataframe['close'] < (dataframe['ema_13'] * 0.988)) &
(dataframe['EWO'] > 6.4) &
(dataframe['rsi'] < 32.0) &
(dataframe['volume'] < (dataframe['volume_mean_4'] * 2.0))
)
dataframe.loc[nfi7_33, ['buy', 'buy_tag']] = (1, 'nfi7_33')
# nfi_38
nfi_38 = (
bool(self.nfi_38_enabled.value) &
(dataframe['pm'] > dataframe['pmax_thresh']) &
(dataframe['close'] < dataframe['sma_75'] * 0.98) &
(dataframe['EWO'] < -4.4) &
(dataframe['cti'] < -0.95) &
(dataframe['r_14'] < -97) &
(dataframe['crsi_1h'] > 0.5)
)
dataframe.loc[nfi_38, ['buy', 'buy_tag']] = (1, 'nfi_38')
return dataframe
def populate_sell_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
conditions = []
conditions.append(
(
(dataframe['close'] > dataframe['sma_9']) &
(dataframe['close'] > (
dataframe[f'ma_sell_{self.base_nb_candles_sell.value}'] * self.high_offset_2.value)) &
(dataframe['rsi'] > 50) &
(dataframe['volume'] > 0) &
(dataframe['uptrend'] == 1) &
(dataframe['rsi_fast'] > dataframe['rsi_slow'])
) |
(
(dataframe['close'] < dataframe['hma_50']) &
(dataframe['close'] > (
dataframe[f'ma_sell_{self.base_nb_candles_sell.value}'] * self.high_offset.value)) &
(dataframe['volume'] > 0) &
(dataframe['uptrend'] == 1) &
(dataframe['rsi_fast'] > dataframe['rsi_slow'])
)
)
if conditions:
dataframe.loc[
reduce(lambda x, y: x | y, conditions),
'sell'
] = 1
return dataframe
def rollingNormalize(self, dataframe, name):
df = dataframe.copy()
df[name + '_nmin'] = df[name].rolling(window=1440 // self.timeframe_minutes).min()
df[name + '_nmax'] = df[name].rolling(window=1440 // self.timeframe_minutes).max()
return np.where(df[name + '_nmin'] == df[name + '_nmax'], 0,
(2.0 * (df[name] - df[name + '_nmin']) / (df[name + '_nmax'] - df[name + '_nmin']) - 1.0))
def EWO(dataframe, ema_length=5, ema2_length=35):
df = dataframe.copy()
ema1 = ta.EMA(df, timeperiod=ema_length)
ema2 = ta.EMA(df, timeperiod=ema2_length)
emadif = (ema1 - ema2) / df['low'] * 100
return emadif
def normalize(data, min_value, max_value):
return (data - min_value) / (max_value - min_value)
def williams_r(dataframe: DataFrame, period: int = 14) -> Series:
"""Williams %R, or just %R, is a technical analysis oscillator showing the current closing price in relation to the high and low
of the past N days (for a given N). It was developed by a publisher and promoter of trading materials, Larry Williams.
Its purpose is to tell whether a stock or commodity market is trading near the high or the low, or somewhere in between,
of its recent trading range.
The oscillator is on a negative scale, from −100 (lowest) up to 0 (highest).
"""
highest_high = dataframe["high"].rolling(center=False, window=period).max()
lowest_low = dataframe["low"].rolling(center=False, window=period).min()
WR = Series(
(highest_high - dataframe["close"]) / (highest_high - lowest_low),
name=f"{period} Williams %R",
)
return WR * -100
def bollinger_bands(stock_price, window_size, num_of_std):
rolling_mean = stock_price.rolling(window=window_size).mean()
rolling_std = stock_price.rolling(window=window_size).std()
lower_band = rolling_mean - (rolling_std * num_of_std)
return np.nan_to_num(rolling_mean), np.nan_to_num(lower_band)
def ha_typical_price(bars):
res = (bars['ha_high'] + bars['ha_low'] + bars['ha_close']) / 3.
return Series(index=bars.index, data=res)
# PMAX
def pmax(df, period, multiplier, length, MAtype, src):
period = int(period)
multiplier = int(multiplier)
length = int(length)
MAtype = int(MAtype)
src = int(src)
mavalue = f'MA_{MAtype}_{length}'
atr = f'ATR_{period}'
pm = f'pm_{period}_{multiplier}_{length}_{MAtype}'
pmx = f'pmX_{period}_{multiplier}_{length}_{MAtype}'
# MAtype==1 --> EMA
# MAtype==2 --> DEMA
# MAtype==3 --> T3
# MAtype==4 --> SMA
# MAtype==5 --> VIDYA
# MAtype==6 --> TEMA
# MAtype==7 --> WMA
# MAtype==8 --> VWMA
# MAtype==9 --> zema
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:
mavalue = ta.EMA(masrc, timeperiod=length)
elif MAtype == 2:
mavalue = ta.DEMA(masrc, timeperiod=length)
elif MAtype == 3:
mavalue = ta.T3(masrc, timeperiod=length)
elif MAtype == 4:
mavalue = ta.SMA(masrc, timeperiod=length)
elif MAtype == 5:
mavalue = ta.VIDYA(df, length=length)
elif MAtype == 6:
mavalue = ta.TEMA(masrc, timeperiod=length)
elif MAtype == 7:
mavalue = ta.WMA(df, timeperiod=length)
elif MAtype == 8:
mavalue = ta.vwma(df, length)
elif MAtype == 9:
mavalue = zema(df, period=length)
df[atr] = ta.ATR(df, timeperiod=period)
df['basic_ub'] = mavalue + ((multiplier / 10) * df[atr])
df['basic_lb'] = mavalue - ((multiplier / 10) * df[atr])
basic_ub = df['basic_ub'].values
final_ub = np.full(len(df), 0.00)
basic_lb = df['basic_lb'].values
final_lb = np.full(len(df), 0.00)
for i in range(period, len(df)):
final_ub[i] = basic_ub[i] if (
basic_ub[i] < final_ub[i - 1]
or mavalue[i - 1] > final_ub[i - 1]) else final_ub[i - 1]
final_lb[i] = basic_lb[i] if (
basic_lb[i] > final_lb[i - 1]
or mavalue[i - 1] < final_lb[i - 1]) else final_lb[i - 1]
df['final_ub'] = final_ub
df['final_lb'] = final_lb
pm_arr = np.full(len(df), 0.00)
for i in range(period, len(df)):
pm_arr[i] = (
final_ub[i] if (pm_arr[i - 1] == final_ub[i - 1]
and mavalue[i] <= final_ub[i])
else final_lb[i] if (
pm_arr[i - 1] == final_ub[i - 1]
and mavalue[i] > final_ub[i]) else final_lb[i]
if (pm_arr[i - 1] == final_lb[i - 1]
and mavalue[i] >= final_lb[i]) else final_ub[i]
if (pm_arr[i - 1] == final_lb[i - 1]
and mavalue[i] < final_lb[i]) else 0.00)
pm = Series(pm_arr)
# Mark the trend direction up/down
pmx = np.where((pm_arr > 0.00), np.where((mavalue < pm_arr), 'down', 'up'), np.NaN)
return pm, pmx
# smoothed Heiken Ashi
def HA(dataframe, smoothing=None):
df = dataframe.copy()
df['HA_Close'] = (df['open'] + df['high'] + df['low'] + df['close']) / 4
df.reset_index(inplace=True)
ha_open = [(df['open'][0] + df['close'][0]) / 2]
[ha_open.append((ha_open[i] + df['HA_Close'].values[i]) / 2) for i in range(0, len(df) - 1)]
df['HA_Open'] = ha_open
df.set_index('index', inplace=True)
df['HA_High'] = df[['HA_Open', 'HA_Close', 'high']].max(axis=1)
df['HA_Low'] = df[['HA_Open', 'HA_Close', 'low']].min(axis=1)
if smoothing is not None:
sml = abs(int(smoothing))
if sml > 0:
df['Smooth_HA_O'] = ta.EMA(df['HA_Open'], sml)
df['Smooth_HA_C'] = ta.EMA(df['HA_Close'], sml)
df['Smooth_HA_H'] = ta.EMA(df['HA_High'], sml)
df['Smooth_HA_L'] = ta.EMA(df['HA_Low'], sml)
return df
def pump_warning(dataframe, perc=15):
df = dataframe.copy()
df["change"] = df["high"] - df["low"]
df["test1"] = (df["close"] > df["open"])
df["test2"] = ((df["change"] / df["low"]) > (perc / 100))
df["result"] = (df["test1"] & df["test2"]).astype('int')
return df['result']
# VWAP bands
def VWAPB(dataframe, window_size=20, num_of_std=1):
df = dataframe.copy()
df['vwap'] = qtpylib.rolling_vwap(df, window=window_size)
rolling_std = df['vwap'].rolling(window=window_size).std()
df['vwap_low'] = df['vwap'] - (rolling_std * num_of_std)
df['vwap_high'] = df['vwap'] + (rolling_std * num_of_std)
return df['vwap_low'], df['vwap'], df['vwap_high']
# Chaikin Money Flow
def chaikin_money_flow(dataframe, n=20, fillna=False) -> Series:
"""Chaikin Money Flow (CMF)
It measures the amount of Money Flow Volume over a specific period.
http://stockcharts.com/school/doku.php?id=chart_school:technical_indicators:chaikin_money_flow_cmf
Args:
dataframe(pandas.Dataframe): dataframe containing ohlcv
n(int): n period.
fillna(bool): if True, fill nan values.
Returns:
pandas.Series: New feature generated.
"""
mfv = ((dataframe['close'] - dataframe['low']) - (dataframe['high'] - dataframe['close'])) / (
dataframe['high'] - dataframe['low'])
mfv = mfv.fillna(0.0) # float division by zero
mfv *= dataframe['volume']
cmf = (mfv.rolling(n, min_periods=0).sum()
/ dataframe['volume'].rolling(n, min_periods=0).sum())
if fillna:
cmf = cmf.replace([np.inf, -np.inf], np.nan).fillna(0)
return Series(cmf, name='cmf')
def T3(dataframe, length=5):
"""
T3 Average by HPotter on Tradingview
https://www.tradingview.com/script/qzoC9H1I-T3-Average/
"""
df = dataframe.copy()
df['xe1'] = ta.EMA(df['close'], timeperiod=length)
df['xe2'] = ta.EMA(df['xe1'], timeperiod=length)
df['xe3'] = ta.EMA(df['xe2'], timeperiod=length)
df['xe4'] = ta.EMA(df['xe3'], timeperiod=length)
df['xe5'] = ta.EMA(df['xe4'], timeperiod=length)
df['xe6'] = ta.EMA(df['xe5'], timeperiod=length)
b = 0.7
c1 = -b * b * b
c2 = 3 * b * b + 3 * b * b * b
c3 = -6 * b * b - 3 * b - 3 * b * b * b
c4 = 1 + 3 * b + b * b * b + 3 * b * b
df['T3Average'] = c1 * df['xe6'] + c2 * df['xe5'] + c3 * df['xe4'] + c4 * df['xe3']
return df['T3Average']
# Modified Elder Ray Index
def moderi(dataframe: DataFrame, len_slow_ma: int = 32) -> Series:
slow_ma = Series(ta.EMA(vwma(dataframe, length=len_slow_ma), timeperiod=len_slow_ma))
return slow_ma >= slow_ma.shift(1) # we just need true & false for ERI trend
# Volume Weighted Moving Average
def vwma(dataframe: DataFrame, length: int = 10):
"""Indicator: Volume Weighted Moving Average (VWMA)"""
# Calculate Result
pv = dataframe['close'] * dataframe['volume']
vwma = Series(ta.SMA(pv, timeperiod=length) / ta.SMA(dataframe['volume'], timeperiod=length))
return vwma
# Mom DIV
def momdiv(dataframe: DataFrame, mom_length: int = 10, bb_length: int = 20, bb_dev: float = 2.0,
lookback: int = 30) -> DataFrame:
mom: Series = ta.MOM(dataframe, timeperiod=mom_length)
upperband, middleband, lowerband = ta.BBANDS(mom, timeperiod=bb_length, nbdevup=bb_dev, nbdevdn=bb_dev, matype=0)
buy = qtpylib.crossed_below(mom, lowerband)
sell = qtpylib.crossed_above(mom, upperband)
hh = dataframe['high'].rolling(lookback).max()
ll = dataframe['low'].rolling(lookback).min()
coh = dataframe['high'] >= hh
col = dataframe['low'] <= ll
df = DataFrame({
"momdiv_mom": mom,
"momdiv_upperb": upperband,
"momdiv_lowerb": lowerband,
"momdiv_buy": buy,
"momdiv_sell": sell,
"momdiv_coh": coh,
"momdiv_col": col,
}, index=dataframe['close'].index)
return df