def indicator():
# We must have AroonPeriod ldb.price_list candles
if len(ldb.price_list) >= gc.Aroon.Period:
storage.writelist(
'Aroon_Up_list', 100 * (gc.Aroon.Period - (gc.Aroon.Period - ([
i for i, x in enumerate(ldb.price_list)
if x == max(ldb.price_list[(gc.Aroon.Period * -1):])
][0] + 1)) / gc.Aroon.Period))
storage.writelist(
'Aroon_Down_list',
100 * (gc.Aroon.Period - (gc.Aroon.Period - ([
i for i, x in enumerate(ldb.price_list)
if x == min(ldb.price_list[(gc.Aroon.Period * -1):])
][0] + 1)) / gc.Aroon.Period))
storage.writelist(
'Aroon_ind_list',
storage.getlist('Aroon_Up_list')[-1] -
storage.getlist('Aroon_Down_list')[-1])
if 'Aroon' in gc.Trader.VerboseIndicators:
if not storage.getlist('Aroon_ind_list'):
print(
'Aroon: Not yet enough data to determine trend or calculate'
)
else:
gu.PrintIndicatorTrend('Aroon',
storage.getlist('Aroon_Up_list'),
storage.getlist('Aroon_Down_list'),
storage.getlist('Aroon_ind_list'),
gc.Aroon.Bid, gc.Aroon.Ask, False)
def indicator():
# We can start DEMAs once we have max period candles
if len(storage.getlist('EMA_Long_list')) >= max(
gc.EMA.LongPeriod, gc.EMA.ShortPeriod):
storage.writelist(
'DEMA_Short_list',
Helpers.DEMA(storage.getlist('EMA_Short_list'),
storage.getlist('DEMA_Short_list'),
gc.EMA.ShortPeriod))
storage.writelist(
'DEMA_Long_list',
Helpers.DEMA(storage.getlist('EMA_Long_list'),
storage.getlist('DEMA_Long_list'),
gc.EMA.LongPeriod))
storage.writelist(
'DEMA_Diff_list',
Helpers.ListDiff(storage.getlist('DEMA_Short_list'),
storage.getlist('DEMA_Long_list')))
if 'DEMA' in gc.Trader.VerboseIndicators:
if not storage.getlist('DEMA_Long_list'):
print('DEMA: Not yet enough data to determine trend')
else:
gu.PrintIndicatorTrend('DEMA',
storage.getlist('DEMA_Short_list'),
storage.getlist('DEMA_Long_list'),
storage.getlist('DEMA_Diff_list'),
gc.DEMA.DiffDown, gc.DEMA.DiffUp)
def indicator():
if len(ldb.price_list) >= gc.KDJ.FastKPeriod:
try:
storage.writelist(
'KDJ_FastK_list',
Helpers.FastStochK(ldb.price_list, gc.KDJ.FastKPeriod))
except ZeroDivisionError:
pass
if len(storage.getlist('KDJ_FastK_list')) >= gc.KDJ.FullKPeriod:
storage.writelist(
'KDJ_FullK_list',
Helpers.SMA(storage.getlist('KDJ_FastK_list'),
gc.KDJ.FullKPeriod))
if len(storage.getlist('KDJ_FullK_list')) >= gc.KDJ.FullDPeriod:
storage.writelist(
'KDJ_FullD_list',
Helpers.SMA(storage.getlist('KDJ_FullK_list'),
gc.KDJ.FullDPeriod))
if storage.getlist('KDJ_FullD_list'):
storage.writelist('KDJ_J_list',
(3 * storage.getlist('KDJ_FullD_list')[-1]) -
(2 * storage.getlist('KDJ_FullK_list')[-1]))
if 'KDJ' in gc.Trader.VerboseIndicators:
if not storage.getlist('KDJ_J_list'):
print(
'KDJ: Not yet enough data to determine trend or calculate')
else:
gu.PrintIndicatorTrend('KDJ',
storage.getlist('KDJ_FullK_list'),
storage.getlist('KDJ_FullD_list'),
storage.getlist('KDJ_J_list'),
gc.KDJ.Bid, gc.KDJ.Ask, False)
def indicator():
# We can start FRAMAs once we have max period candles
if len(ldb.price_list) >= (max(gc.FRAMA.LongPeriod,
gc.FRAMA.ShortPeriod)):
try:
storage.writelist(
'FRAMA_Short_list',
Helpers.FRAMA(ldb.price_list,
storage.getlist('FRAMA_Short_list'),
gc.FRAMA.ShortPeriod))
storage.writelist(
'FRAMA_Long_list',
Helpers.FRAMA(ldb.price_list,
storage.getlist('FRAMA_Long_list'),
gc.FRAMA.LongPeriod))
storage.writelist(
'FRAMA_Diff_list',
Helpers.ListDiff(storage.getlist('FRAMA_Short_list'),
storage.getlist('FRAMA_Long_list')))
# For a math domain error from log operations at low volatility or high
# frequency
except ValueError:
pass
if 'FRAMA' in gc.Trader.VerboseIndicators:
if not storage.getlist('FRAMA_Long_list'):
print('FRAMA: Not yet enough data to determine trend')
else:
gu.PrintIndicatorTrend('FRAMA',
storage.getlist('FRAMA_Short_list'),
storage.getlist('FRAMA_Long_list'),
storage.getlist('FRAMA_Diff_list'),
gc.FRAMA.DiffDown, gc.FRAMA.DiffUp)
def indicator():
# We can start MACD EMAs once we have LongPeriod candles
if len(ldb.price_list) >= genconfig.MACD.LongPeriod:
MACD.Short_list.append(Helpers.EMA(ldb.price_list, MACD.Short_list,\
genconfig.MACD.ShortPeriod))
MACD.Long_list.append(Helpers.EMA(ldb.price_list, MACD.Long_list,\
genconfig.MACD.LongPeriod))
MACD.ind_list.append(MACD.Short_list[-1] - MACD.Long_list[-1])
# We need SignalPeriod MACDs before generating MACDSignal
if len(MACD.Long_list) >= genconfig.MACD.SignalPeriod:
MACD.Signal_list.append(Helpers.EMA(MACD.ind_list, MACD.Signal_list,\
genconfig.MACD.SignalPeriod))
# TODO: use this someday...
MACD.Histogram_list.append(MACD.ind_list[-1] -
MACD.Signal_list[-1])
if 'MACD' in genconfig.VerboseIndicators:
if len(MACD.Signal_list) < 1:
print('MACD: Not yet enough data to determine trend')
else:
gu.PrintIndicatorTrend('MACD', MACD.Signal_list, MACD.ind_list,\
MACD.ind_list, genconfig.MACD.DiffDown,\
genconfig.MACD.DiffUp)
def indicator():
# We can start MACD EMAs once we have max period candles
print(
'MACD_Short_list',
Helpers.EMA(ldb.price_list, storage.getlist('MACD_Short_list'),
gc.MACD.ShortPeriod))
print(
'MACD_Long_list',
Helpers.EMA(ldb.price_list, storage.getlist('MACD_Long_list'),
gc.MACD.LongPeriod))
if len(ldb.price_list) >= max(gc.MACD.LongPeriod, gc.MACD.ShortPeriod):
storage.writelist(
'MACD_Short_list',
Helpers.EMA(ldb.price_list, storage.getlist('MACD_Short_list'),
gc.MACD.ShortPeriod))
storage.writelist(
'MACD_Long_list',
Helpers.EMA(ldb.price_list, storage.getlist('MACD_Long_list'),
gc.MACD.LongPeriod))
storage.writelist(
'MACD_ind_list',
storage.getlist('MACD_Short_list')[-1] -
storage.getlist('MACD_Long_list')[-1])
print(
'MACD_ind_list',
storage.getlist('MACD_Short_list')[-1] -
storage.getlist('MACD_Long_list')[-1])
# We need SignalPeriod MACDs before generating MACDSignal
if len(storage.getlist('MACD_Long_list')) >= gc.MACD.SignalPeriod:
storage.writelist(
'MACD_Signal_list',
Helpers.EMA(storage.getlist('MACD_ind_list'),
storage.getlist('MACD_Signal_list'),
gc.MACD.SignalPeriod))
storage.writelist(
'MACD_Histogram_list',
storage.getlist('MACD_ind_list')[-1] -
storage.getlist('MACD_Signal_list')[-1])
if 'MACD' in gc.Trader.VerboseIndicators:
if not storage.getlist('MACD_Signal_list'):
print('MACD: Not yet enough data to determine trend')
else:
gu.PrintIndicatorTrend('MACD',
storage.getlist('MACD_ind_list'),
storage.getlist('MACD_Signal_list'),
storage.getlist('MACD_ind_list'),
gc.MACD.DiffDown, gc.MACD.DiffUp)
print('MACD Hist:',
storage.getlist('MACD_Histogram_list')[-1])
def indicator():
# We can start SMA calculations once we have SMALongPeriod
# price candles, otherwise we append None until met
if len(ldb.price_list) >= genconfig.SMA.LongPeriod:
SMA.Short_list.append(
Helpers.SMA(ldb.price_list, genconfig.SMA.ShortPeriod))
SMA.Long_list.append(
Helpers.SMA(ldb.price_list, genconfig.SMA.LongPeriod))
if len(SMA.Long_list) >= 1:
SMA.Diff_list.append(100 * (SMA.Short_list[-1] - SMA.Long_list[-1])\
/ ((SMA.Short_list[-1] + SMA.Long_list[-1]) / 2))
if 'SMA' in genconfig.VerboseIndicators:
if len(SMA.Long_list) < 1:
print('SMA: Not yet enough data to determine trend')
else:
gu.PrintIndicatorTrend('SMA', SMA.Short_list, SMA.Long_list,\
SMA.Diff_list, genconfig.SMA.DiffDown,genconfig.SMA.DiffUp)
def indicator():
# We can start DEMAs once we have an EMALong candles
if len(DEMA.Long_list) >= genconfig.EMA.LongPeriod:
DEMA.Short_list.append(Helpers.DEMA(EMA.Short_list, DEMA.Short_list,\
genconfig.EMA.ShortPeriod))
DEMA.Long_list.append(Helpers.DEMA(EMA.Long_list, DEMA.Long_list,\
genconfig.EMA.LongPeriod))
# We can calculate Diff when we have both LongPeriod and ShortPeriod
if len(DEMA.Long_list) >= 1:
DEMA.Diff_list.append(100 * (DEMA.Short_list[-1] - DEMA.Long_list[-1])\
/ ((Short_list[-1] + DEMA.Long_list[-1]) / 2))
if 'DEMA' in genconfig.VerboseIndicators:
if len(DEMA.Long_list) < 1:
print('DEMA: Not yet enough data to determine trend')
else:
gu.PrintIndicatorTrend('DEMA', DEMA.Short_list, DEMA.Long_list,\
DEMA.Diff_list, genconfig.DEMA.DiffDown,\
genconfig.DEMA.DiffUp)
def indicator():
# We can start EMAs once we have EMALong candles
if len(ldb.price_list) >= genconfig.EMA.LongPeriod:
EMA.Short_list.append(Helpers.EMA(ldb.price_list, EMA.Short_list,\
genconfig.EMA.ShortPeriod))
EMA.Long_list.append(Helpers.EMA(ldb.price_list, EMA.Long_list,\
genconfig.EMA.LongPeriod))
# We can calculate Diff when we have both EMALong and EMAShort
if len(EMA.Long_list) >= 1:
EMA.Diff_list.append(100 * (EMA.Short_list[-1] - EMA.Long_list[-1])\
/ ((EMA.Short_list[-1] + EMA.Long_list[-1]) / 2))
if 'EMA' in genconfig.VerboseIndicators:
if len(EMA.Long_list) < 1:
print('EMA: Not yet enough data to determine trend')
else:
gu.PrintIndicatorTrend('EMA', EMA.Short_list, EMA.Long_list,\
EMA.Diff_list, genconfig.EMA.DiffDown,\
genconfig.EMA.DiffUp)
def indicator():
# We must have AroonPeriod ldb.price_list candles
if len(ldb.price_list) >= genconfig.Aroon.Period:
Aroon.Up_list.append(100 * (genconfig.Aroon.Period -\
(genconfig.Aroon.Period - ([i for i,x in enumerate(ldb.price_list)\
if x == max(ldb.price_list[(genconfig.Aroon.Period * -1):])][0] + 1\
)) / genconfig.Aroon.Period))
Aroon.Down_list.append(100 * (genconfig.Aroon.Period -\
(genconfig.Aroon.Period - ([i for i,x in enumerate(ldb.price_list)\
if x == min(ldb.price_list[(genconfig.Aroon.Period * -1):])][0] + 1\
)) / genconfig.Aroon.Period))
Aroon.ind_list.append(Aroon.Up_list[-1] - Aroon.Down_list[-1])
if 'Aroon' in genconfig.VerboseIndicators:
if len(Aroon.ind_list) < 1:
print(
'Aroon: Not yet enough data to determine trend or calculate'
)
else:
gu.PrintIndicatorTrend('Aroon', Aroon.Down_list, Aroon.Up_list,\
Aroon.ind_list, genconfig.Aroon.Bid, genconfig.Aroon.Ask, False)
def indicator():
if len(ldb.price_list) >= genconfig.KDJ.FastKPeriod:
KDJ.FastK_list.append(Helpers.FastStochK(ldb.price_list,\
genconfig.KDJ.FastKPeriod))
if len(KDJ.FastK_list) >= genconfig.KDJ.FullKPeriod:
KDJ.FullK_list.append(Helpers.SMA(KDJ.FastK_list,\
genconfig.KDJ.FullKPeriod))
if len(KDJ.FullK_list) >= genconfig.KDJ.FullDPeriod:
KDJ.FullD_list.append(Helpers.SMA(KDJ.FullK_list,\
genconfig.KDJ.FullDPeriod))
if len(KDJ.FullD_list) >= 1:
KDJ.J_list.append((3 * KDJ.FullD_list[-1]) -
(2 * KDJ.FullK_list[-1]))
if 'KDJ' in genconfig.VerboseIndicators:
if len(KDJ.J_list) < 1:
print(
'KDJ: Not yet enough data to determine trend or calculate')
else:
gu.PrintIndicatorTrend('KDJ', KDJ.FullD_list, KDJ.FullK_list,\
KDJ.J_list, genconfig.KDJ.Bid, genconfig.KDJ.Ask, False)
def indicator():
# We can start DMACD EMAs once we have MACDLong candles
if len(MACD.Long_list) >= genconfig.MACD.LongPeriod:
DMACD.Short_list.append(Helpers.DEMA(MACD.Short_list, DMACD.Short_list,\
genconfig.MACD.ShortPeriod))
DMACD.Long_list.append(Helpers.DEMA(MACD.Long_list, DMACD.Long_list,\
genconfig.MACD.LongPeriod))
DMACD.ind_list.append(DMACD.Short_list[-1] - DMACD.Long_list[-1])
# We need MACDSignal DMACDs before generating Signal
if len(DMACD.Long_list) >= (genconfig.MACD.SignalPeriod +\
(abs(genconfig.MACD.SignalPeriod - genconfig.MACD.LongPeriod))):
DMACD.Signal_list.append(Helpers.DEMA(MACD.Signal_list,\
DMACD.Signal_list, genconfig.MACD.SignalPeriod))
DMACD.Histogram_list.append(DMACD.ind_list[-1] -
DMACD.Signal_list[-1])
if 'DMACD' in genconfig.VerboseIndicators:
if len(DMACD.Signal_list) < 1:
print('DMACD: Not yet enough data to determine trend')
else:
gu.PrintIndicatorTrend('DMACD', DMACD.Signal_list, DMACD.ind_list,\
DMACD.ind_list, genconfig.DMACD.DiffDown,\
genconfig.DMACD.DiffUp)
