def get_adx_values(inputs):
adx_values = ta.adx(inputs['high'], inputs['low'], inputs['close'])
"""
array
dict
name name
array values
"""
resp_array = []
adx_dict = {}
adx_dict['name'] = "adx"
adx_dict['data'] = adx_values['ADX_14'].dropna().round(2).values.tolist()
resp_array.append(adx_dict)
di_minus_dict = {}
di_minus_dict['name'] = "di_minus"
di_minus_dict['data'] = adx_values['DMN_14'].dropna().round(2).values.tolist()
resp_array.append(di_minus_dict)
di_plus_dict = {}
di_plus_dict['name'] = "di_plus"
di_plus_dict['data'] = adx_values['DMP_14'].dropna().round(2).values.tolist()
resp_array.append(di_plus_dict)
return resp_array
def adx(s_interval: str, df_stock: pd.DataFrame, length: int, scalar: int,
drift: int):
"""ADX technical indicator
Parameters
----------
s_interval : str
Interval of stock data
df_stock : pd.DataFrame
Dataframe with prices
length: int
Length of window
scalar: int
Scalar variable
droft: int
Drift variable
Returns
-------
df_ta: pd.DataFrame
DataFrame with adx indicator
"""
# Daily
if s_interval == "1440min":
df_ta = ta.adx(
high=df_stock["High"],
low=df_stock["Low"],
close=df_stock["Adj Close"],
length=length,
scalar=scalar,
drift=drift,
).dropna()
# Intraday
else:
df_ta = ta.adx(
high=df_stock["High"],
low=df_stock["Low"],
close=df_stock["Close"],
length=length,
scalar=scalar,
drift=drift,
).dropna()
return df_ta
def get_adx_values(inputs):
adx_values = ta.adx(inputs['high'], inputs['low'], inputs['close'])
#print(adx_values)
ret_dict = {}
ret_dict['adx'] = adx_values['ADX_14'].values.tolist()[-items_ret:]
ret_dict['di_minus'] = adx_values['DMN_14'].values.tolist()[-items_ret:]
ret_dict['di_plus'] = adx_values['DMP_14'].values.tolist()[-items_ret:]
#print(ret_dict)
return ret_dict
def get_adx_values(inputs):
adx_values = ta.adx(inputs['high'], inputs['low'], inputs['close'])
ret_dict = {}
ret_dict['adx'] = adx_values['ADX_14'].dropna().round(2).values.tolist()
ret_dict['di_minus'] = adx_values['DMN_14'].dropna().round(
2).values.tolist()
ret_dict['di_plus'] = adx_values['DMP_14'].dropna().round(
2).values.tolist()
return ret_dict
def adx(
high_values: pd.Series,
low_values: pd.Series,
close_values: pd.Series,
length: int = 14,
scalar: int = 100,
drift: int = 1,
):
"""ADX technical indicator
Parameters
----------
high_values: pd.Series
High prices
low_values: pd.Series
Low prices
close_values: pd.Series
close prices
length: int
Length of window
scalar: int
Scalar variable
drift: int
Drift variable
Returns
-------
pd.DataFrame
DataFrame with adx indicator
"""
return pd.DataFrame(
ta.adx(
high=high_values,
low=low_values,
close=close_values,
length=length,
scalar=scalar,
drift=drift,
).dropna()
)
def getADXIndicator(data):
adx = ta.adx(data["high"], data["low"], data["close"])
return adx
def adx(l_args, s_ticker, s_interval, df_stock):
parser = argparse.ArgumentParser(
prog='adx',
description=
""" The ADX is a Welles Wilder style moving average of the Directional
Movement Index (DX). The values range from 0 to 100, but rarely get above 60.
To interpret the ADX, consider a high number to be a strong trend, and a low number,
a weak trend. """)
parser.add_argument('-l',
"--length",
action="store",
dest="n_length",
type=check_positive,
default=14,
help='length')
parser.add_argument('-s',
"--scalar",
action="store",
dest="n_scalar",
type=check_positive,
default=100,
help='scalar')
parser.add_argument('-d',
"--drift",
action="store",
dest="n_drift",
type=check_positive,
default=1,
help='drift')
parser.add_argument('-o',
"--offset",
action="store",
dest="n_offset",
type=check_positive,
default=0,
help='offset')
(ns_parser, l_unknown_args) = parser.parse_known_args(l_args)
if l_unknown_args:
print(
f"The following args couldn't be interpreted: {l_unknown_args}\n")
return
# Daily
if s_interval == "1440min":
df_ta = ta.adx(high=df_stock['2. high'],
low=df_stock['3. low'],
close=df_stock['5. adjusted close'],
length=ns_parser.n_length,
scalar=ns_parser.n_scalar,
drift=ns_parser.n_drift,
offset=ns_parser.n_offset).dropna()
plt.subplot(211)
plt.plot(df_stock.index,
df_stock['5. adjusted close'].values,
'k',
lw=2)
plt.title(f"Average Directional Movement Index (ADX) on {s_ticker}")
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.ylabel(f'Share Price ($)')
plt.grid(b=True, which='major', color='#666666', linestyle='-')
plt.minorticks_on()
plt.grid(b=True,
which='minor',
color='#999999',
linestyle='-',
alpha=0.2)
plt.subplot(212)
plt.plot(df_ta.index, df_ta.iloc[:, 0].values, 'b', lw=2)
plt.plot(df_ta.index, df_ta.iloc[:, 1].values, 'g', lw=1)
plt.plot(df_ta.index, df_ta.iloc[:, 2].values, 'r', lw=1)
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.axhline(25, linewidth=3, color='k', ls='--')
plt.legend([
f'ADX ({df_ta.columns[0]})', f'+DI ({df_ta.columns[1]})',
f'- DI ({df_ta.columns[2]})'
])
plt.xlabel('Time')
plt.grid(b=True, which='major', color='#666666', linestyle='-')
plt.minorticks_on()
plt.grid(b=True,
which='minor',
color='#999999',
linestyle='-',
alpha=0.2)
plt.ylim([0, 100])
plt.show()
# Intraday
else:
df_ta = ta.adx(high=df_stock['2. high'],
low=df_stock['3. low'],
close=df_stock['4. close'],
length=ns_parser.n_length,
scalar=ns_parser.n_scalar,
drift=ns_parser.n_drift,
offset=ns_parser.n_offset).dropna()
plt.subplot(211)
plt.plot(df_stock.index, df_stock['4. close'].values, 'k', lw=2)
plt.title(f"Average Directional Movement Index (ADX) on {s_ticker}")
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.ylabel(f'Share Price ($)')
plt.grid(b=True, which='major', color='#666666', linestyle='-')
plt.minorticks_on()
plt.grid(b=True,
which='minor',
color='#999999',
linestyle='-',
alpha=0.2)
plt.subplot(212)
plt.plot(df_ta.index, df_ta.iloc[:, 0].values, 'b', lw=2)
plt.plot(df_ta.index, df_ta.iloc[:, 1].values, 'g', lw=1)
plt.plot(df_ta.index, df_ta.iloc[:, 2].values, 'r', lw=1)
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.axhline(25, linewidth=3, color='k', ls='--')
plt.legend([
f'ADX ({df_ta.columns[0]})', f'+DI ({df_ta.columns[1]})',
f'- DI ({df_ta.columns[2]})'
])
plt.xlabel('Time')
plt.grid(b=True, which='major', color='#666666', linestyle='-')
plt.minorticks_on()
plt.grid(b=True,
which='minor',
color='#999999',
linestyle='-',
alpha=0.2)
plt.ylim([0, 100])
plt.show()
print("")
def add_adx():
df = ta.adx(data['2. high'], data['3. low'], data['4. close'])
data['ADX'] = df['ADX_14']
data['DMP'] = df['DMP_14']
data['DMN'] = df['DMN_14']
def adx(l_args, s_ticker, s_interval, df_stock):
parser = argparse.ArgumentParser(
add_help=False,
prog="adx",
description="""
The ADX is a Welles Wilder style moving average of the Directional Movement Index (DX).
The values range from 0 to 100, but rarely get above 60. To interpret the ADX, consider
a high number to be a strong trend, and a low number, a weak trend.
""",
)
parser.add_argument(
"-l",
"--length",
action="store",
dest="n_length",
type=check_positive,
default=14,
help="length",
)
parser.add_argument(
"-s",
"--scalar",
action="store",
dest="n_scalar",
type=check_positive,
default=100,
help="scalar",
)
parser.add_argument(
"-d",
"--drift",
action="store",
dest="n_drift",
type=check_positive,
default=1,
help="drift",
)
parser.add_argument(
"-o",
"--offset",
action="store",
dest="n_offset",
type=check_positive,
default=0,
help="offset",
)
try:
ns_parser = parse_known_args_and_warn(parser, l_args)
if not ns_parser:
return
# Daily
if s_interval == "1440min":
df_ta = ta.adx(
high=df_stock["2. high"],
low=df_stock["3. low"],
close=df_stock["5. adjusted close"],
length=ns_parser.n_length,
scalar=ns_parser.n_scalar,
drift=ns_parser.n_drift,
offset=ns_parser.n_offset,
).dropna()
# Intraday
else:
df_ta = ta.adx(
high=df_stock["2. high"],
low=df_stock["3. low"],
close=df_stock["4. close"],
length=ns_parser.n_length,
scalar=ns_parser.n_scalar,
drift=ns_parser.n_drift,
offset=ns_parser.n_offset,
).dropna()
plot_adx(df_stock, s_ticker, df_ta)
print("")
except Exception as e:
print(e)
print("")
from ta.volatility import BollingerBands
from modules.crypto.processing import get_volume_analisys, get_volume_profile
load_dotenv()
bot = os.environ["telegram_token_bot"]
df = pd.read_csv('datasets/ETHUSDT-1m-sma-15.csv')
print(df)
df["EMA12"] = ta.ema(high=df.high, low=df.low, close=df.close, length=12)
df["RSI2"] = ta.rsi(high=df.high, low=df.low, close=df.close, length=14)
df['ATR2'] = df.ta.atr()
df['Momentum'] = df.ta.mom()
df['adx'] = ta.adx(high=df.high, low=df.low, close=df.close, length=14)['ADX_14']
print('---------------------')
df['pvt'] = ta.pvt(close=df.close, volume=df.volume)
indicator_bb = BollingerBands(close=df.close, window=14, window_dev=2)
df['bb_bbm'] = indicator_bb.bollinger_mavg()
df['bb_bbh'] = indicator_bb.bollinger_hband()
df['bb_bbl'] = indicator_bb.bollinger_lband()
df['bb_bbhi'] = indicator_bb.bollinger_hband_indicator()
df['bb_bbli'] = indicator_bb.bollinger_lband_indicator()
macd = ta.macd(close=df.close, fast=12, slow=26, signal_indicators=True, signal=9)
df['macd_osc'] = macd['MACD_12_26_9']
df['macd_h'] = macd['MACDh_12_26_9']
def start_analyze(self, stock_code):
data_frame = self.__data_center.fetch_base_data(stock_code)
# ret_val = ta.stdev(data_frame['close'], length=10)
ret_val = ta.adx(data_frame['high'], data_frame['low'], data_frame['close'])
self.draw_close_and_rst(data_frame['close'], ret_val, stock_code)
return ret_val
if df.empty:
continue
df['20sma'] = ta.sma(df['Close'], length=20)
df['stddev'] = df['Close'].rolling(window=20).std()
df['lower_band'] = df['20sma'] - (1 * df['stddev'])
df['upper_band'] = df['20sma'] + (1 * df['stddev'])
df['TR'] = abs(df['High'] - df['Low'])
df['ATR'] = df['TR'].rolling(window=20).mean()
df['lower_keltner'] = df['20sma'] - (df['ATR'] * 1)
df['upper_keltner'] = df['20sma'] + (df['ATR'] * 1)
df['diff'] = (df['upper_band'] - df['lower_band']) / df['20sma']
ADX = ta.adx(df['High'], df['Low'], df['Close'], length=14)
RSI = ta.rsi(df['Close'], length=14)
def tight_squeeze(df):
return df['lower_band'] > df['lower_keltner'] and df[
'upper_band'] < df['upper_keltner']
def above_keltner(df):
return df['Open'] > df['upper_keltner']
def is_consolidating(df):
re_close = df[-10:]
max_close = re_close['Close'].max()
min_close = re_close['Close'].min()
if min_close > (max_close * 0.98):
