def __init__(self, stockObj):
self.stock = stockObj
self.kd = KD(stockObj)
self.macd = MACD(stockObj)
self.dmi = DMI(stockObj)
self.aroon = AROON(stockObj)
self.cci = CCI(stockObj)
self.cmo = CMO(stockObj)
self.days = len(self.kd.k)
def main():
runners = [MACD(stock, 10, alpaca) for stock in STOCKS]
while True:
try:
awaitMarketOpen()
for runner in runners:
runner.run()
time.sleep(60)
except ConnectionError as e:
print(f"connection error: {e}")
def EIS(close):
eis = []
macd, signal, histogram = MACD(close)
eis.append('b')
ema13 = EMA(close, 13)
for i in range(1, len(close)):
if ema13[i] > ema13[i - 1] and histogram[i] > histogram[i - 1]:
eis.append('g')
elif ema13[i] < ema13[i - 1] and histogram[i] < histogram[i - 1]:
eis.append('r')
else:
eis.append('b')
return eis
class MACDSignalLine:
data = start = SignalLine = MACD = None
SMOOTHING = 2
def __init__(self, data):
self.data = data
self.start = data.startDay()
self.MACD = MACD(data)
self.calcSignalLine()
def calcSignalLine(self):
self.SignalLine = defaultdict()
SMA = 0
for x in range(self.start, self.start + 9):
SMA += self.MACD.get(x)
SMA = SMA / 9
self.SignalLine[self.start + 8] = SMA
k = self.SMOOTHING / float(9 + 1)
for x in range(self.start + 9, self.data.getYesterday() + 1):
val = self.MACD.get(x) * k + self.SignalLine[x - 1] * (1 - k)
self.SignalLine[x] = val
# now = self.data.getToday()
# val = self.MACD.get(now)*k + self.SignalLine[now-1]*(1-k)
# SignalLine[now] = val
def currentSignalLine(self):
now = self.data.getToday()
# k = SMOOTHING/float(9+1)
# val = self.MACD.get(now)*k + self.SignalLine[now-1]*(1-k)
# SignalLine[now] = val
# return val
def get(self, day):
return self.SignalLine[day]
def printSignalLine(self):
for k, v in self.SignalLine.items():
print(self.data.getDate(k), v)
def TrendlineTrack(stock,Verbose):
try:
today = datetime.date.today()
startWatch = today - datetime.timedelta(days = 10)
tickerFetch = charts.Ticker(str(stock))
stockData = tickerFetch.history(period = '1d', start = startWatch, end = str(today))
#"Verbose" plotting
CurrentDay = []
CloseValue = []
for i in range(len(stockData)):
CloseValue.append(stockData.iloc[i][3])
CurrentDay.append(i)
PairedData = dict(zip(CurrentDay,CloseValue))
if Verbose == True:
print("Data for " + str(stock)+":\n")
print(PairedData)
else:
pass
CurrentStock = MACD(stockData)
SignalLineValues = CurrentStock.getSignalLineValues()
MACDValues = CurrentStock.getMACDValues()
SignalSet = WhereCross(byday = list(range(0,9)), macd_vals = MACDValues, signal_vals = SignalLineValues)
MarkedEvents = SignalSet.do()
BuyIndications = MarkedEvents[0]
SellIndications = MarkedEvents[1]
StrongBuyIndication = MarkedEvents[2]
return list([stock,BuyIndications,SellIndications,StrongBuyIndication])
except IndexError:
sys.exit("IndexError: Fatal>>> Closing...")
def __init__(self, data):
self.data = data
self.start = data.startDay()
self.MACD = MACD(data)
self.calcSignalLine()
# -*- coding: utf-8 -*-
from grs import Stock
from grs import TWSENo
import sys
sys.path.append('../')
from Trade import Trade
from KD import KD
from MA import MA
from DMI import DMI
from MACD import MACD
stock = Stock.createByCSV('2454', '../../data/2454_14MonData.csv')
trade = Trade(stock)
dmi = DMI(stock)
macd = MACD(stock)
print "MACD with adx >16:"
trade.MACD_DMI_1(macd, dmi)
trade.printTradeResult()
kd = KD(stock)
#print "Trade by perfect buy and perfect sell KD:"
#trade.KD_PerfectBuyPerfectSell(kd)
#trade.printTradeResult()
#print "Trade by perfect buy and normal sell KD:"
#trade.KD_PerfectBuyNormalSell(kd)
#trade.printTradeResult()
#print "Trade by normal buy and normal sell KD:"
#trade.KD_NormalBuyNormalSell(kd)
#trade.printTradeResult()
print "Trade by perfect buy and highest k sell KD:"
from Data import Data
from MACD import MACD
from MACDSignalLine import MACDSignalLine
import matplotlib.pyplot as plt
# from matplotlib import style
ticker = 'MDB'
today = '2020-07-17'
yesterday = '2020-07-16'
start = '2018-01-19'
data = Data(ticker,today,yesterday,start)
#print(len(data))
macd = MACD(data)
signal = MACDSignalLine(data)
values = []
for key in sorted(data.openP.keys()):
values.append(data.openP.get(key))
x_axis = range(0, len(values))
plt.plot(x_axis, values)
#print(macd.MACD)
plt.plot(macd.MACD.keys(), macd.MACD.values())
plt.plot(signal.SignalLine.keys(), signal.SignalLine.values())
plt.show()
print(data.openP)
#signal.printSignalLine()
# macd.printMACD()
class Rule():
def __init__(self, stockObj):
self.stock = stockObj
self.kd = KD(stockObj)
self.macd = MACD(stockObj)
self.dmi = DMI(stockObj)
self.aroon = AROON(stockObj)
self.cci = CCI(stockObj)
self.cmo = CMO(stockObj)
self.days = len(self.kd.k)
def __initFlag(self):
self.isKD = 0
self.isKD_30 = 0
self.isKD_65 = 0
self.isKD_70 = 0
self.isKD_80 = 0
self.isKD_turnRight = 0
self.isMACD = 0
self.isMACD_005 = 0
self.isMACD_010 = 0
self.isMACD_020 = 0
self.isMACD_grow = 0
self.isDMI = 0
self.isDMI_020 = 0
self.isDMI_grow = 0
self.isVolume = 0
self.isPrice = 0
self.isDay_min = 0
self.isDay_max2 = 0
self.isDay_max = 0
def __skipRule(self, i):
if self.stock.volume[i] < 1000:
#self.dmi.adx[i] < 18:
return True
else:
return False
def buyRule_kd_cci(self, i):
return (self.kd.isBuyPoint(i) and self.cci.isOverSell(i))
def sellRule_kd_cci(self, i):
return (self.kd.isSellPoint(i) and self.cci.isOverBuy(i))
def buyRule_kd_cmo(self, i):
return (self.kd.isBuyPoint(i) and self.cmo.isOverSell(i))
def sellRule_kd_cmo(self, i):
return (self.kd.isSellPoint(i) and self.cmo.isOverBuy(i))
def buyRule_cci(self, i):
return self.cci.leaveOverSell(i)
def sellRule_cci(self, i):
return (self.cci.enterOverBuy(i) or self.cci.leaveOverBuy(i))
def buyRule_cmo(self, i):
return self.cmo.leaveOverSell(i)
def sellRule_cmo(self, i):
return (self.cmo.enterOverBuy(i) or self.cmo.leaveOverBuy(i))
def buyRule_macd_aroon(self, i):
return (self.aroon.isStrongUp(i) and self.aroon.isUpEnough() \
and self.macd.isBuyPoint(i))
def sellRule_macd_aroon(self, i):
return (self.aroon.isStrongDown(i) and self.aroon.isDownEnough() \
and self.macd.isSellPoint(i))
def buyRule1(self, i):
if self.__skipRule(i):
return False
self.__countBuyRule(i)
if (self.isKD or \
self.isKD_turnRight) and \
self.isKD_30 and \
self.isMACD_010 and \
self.isDMI and \
self.isDay_min:
return True
else:
return False
def buyRule2(self, i):
if self.__skipRule(i):
return False
self.__countBuyRule(i)
if self.isKD and \
self.kd.contiDay[i] < 3 and \
self.kd.k[i] < 40 and \
self.isMACD_020 and \
self.isMACD_grow:
return True
else:
return False
def sellRule1(self, i):
self.__countSellRule(i)
if self.isKD:
return True
else:
return False
def __countBuyRule(self, i):
self.__initFlag()
if self.kd.k[i] > self.kd.d[i]:
self.isKD = 1
if self.kd.k[i] > self.kd.d[i-1] and \
self.kd.k[i-1] < self.kd.k[i-2] and \
self.kd.k[i] < 50:
self.isKD_turnRight = 1
if self.kd.k[i] < 80:
self.isKD_80 = 1
if self.kd.k[i] < 70:
self.isKD_70 = 1
if self.kd.k[i] < 65:
self.isKD_65 = 1
if self.kd.k[i] < 30:
self.isKD_30 = 1
if self.macd.macdhist[i] > 0:
self.isMACD = 1
if self.macd.macdhist[i] > (-0.05):
self.isMACD_005 = 1
if self.macd.macdhist[i] > (-0.1):
self.isMACD_010 = 1
if self.macd.macdhist[i] > (-0.2):
self.isMACD_020 = 1
if self.macd.macdhist[i] > self.macd.macdhist[i - 1]:
self.isMACD_grow = 1
if self.dmi.plus_di[i] > self.dmi.minus_di[i]:
self.isDMI = 1
if (self.dmi.plus_di[i] - self.dmi.minus_di[i]) > (-2):
self.isDMI_020 = 1
if (self.dmi.plus_di[i]-self.dmi.minus_di[i]) > \
(self.dmi.plus_di[i-1]-self.dmi.minus_di[i-1]):
self.isDMI_grow = 1
if self.stock.volume[i] > 1.5 * self.stock.volume[i - 1]:
self.isVolume = 1
if self.stock.price[i] > 1.015 * self.stock.price[i - 2]:
self.isPrice = 1
if min(self.kd.contiDay[i], self.macd.contiDay[i], \
self.dmi.contiDay[i]) < 2:
self.isDay_min = 1
if max(self.kd.contiDay[i], self.macd.contiDay[i], \
self.dmi.contiDay[i]) < 5:
self.isDay_max = 1
if max(self.kd.contiDay[i], self.macd.contiDay[i], \
self.dmi.contiDay[i]) < 3:
self.isDay_max2 = 1
def __countSellRule(self, i):
self.__initFlag()
if self.kd.k[i] < self.kd.d[i] and \
self.kd.k[i] < 75:
self.isKD = 1
if self.macd.macdhist[i] < (0.2):
self.isMACD_020 = 1
if self.macd.macdhist[i] < self.macd.macdhist[i - 1]:
self.isMACD_grow = 1
if (self.dmi.plus_di[i] < self.dmi.minus_di[i]):
self.isDMI = 1
if self.stock.volume[i] > 1.5 * self.stock.volume[i - 1]:
self.isVolume = 1
if self.stock.price[i] < 1.015 * self.stock.price[i - 2]:
self.isPrice = 1
from MACD import MACD
import matplotlib.pyplot as plt
bot = MACD(False)
balance, pnl, hist = bot.backtest('2020-01-01T00:00:00', '2020-02-01T00:00:00')
fig, ax = plt.subplots(figsize=(30, 10))
ax.plot(hist['date'], hist['price'])
for i, row in hist[hist['action'] == 'buy'].iterrows():
ax.scatter(row['date'], row['price'], marker='o', c='green', alpha=0.5)
for i, row in hist[hist['action'] == 'sell'].iterrows():
ax.scatter(row['date'], row['price'], marker='o', c='red', alpha=0.5)
fig.savefig('./graphs/backtrack.png', bbox_inches='tight')
fig.clf()
plt.plot(balance)
plt.savefig("./graphs/balance.png")
plt.clf()
plt.hist(pnl, bins=20)
plt.savefig("./graphs/pnl_distrib.png")