def testNormal(self):
env.run_mode = env.MODE_SIMULATE
st = lib.str2epoch("2019/04/02 09:00", "%Y/%m/%d %H:%M")
ed = lib.str2epoch("2019/04/02 12:00", "%Y/%m/%d %H:%M")
s = SubChart("testNormal", "USD_JPY", "M5", st, ed, 5, 48)
u = s.unitsecs
(t,_,_,_,_,_) = s.getPrices()
self.assertEqual(len(t), len(s.prices[0]))
# 1
i, now = s.getTime(st + 100)
self.assertEqual(i,5)
self.assertEqual(now,1554195600)
# 2
i, now = s.getTime(st + 400)
self.assertEqual(i,6)
self.assertEqual(now,1554195900)
# 3
i, now = s.getTime(ed + 400)
self.assertEqual(i,42)
self.assertEqual(now,1554206700)
# 4
i, now = s.getTime(ed - 500)
self.assertEqual(i,39)
self.assertEqual(now,1554205800)
from event.tick import TickEvent
tickEvent = TickEvent(1554196200+100, 1, 1)
s.onTick(tickEvent)
(t,o,h,l,c,v) = s.getPrices()
self.assertEqual(t[-1], 1554196200)
self.assertEqual(o[-1], 111.372)
self.assertEqual(v[-1], 22)
(t,o,h,l,c,v) = s.getPrices(5)
self.assertEqual(t[0], 1554195600)
self.assertEqual(t[-1], 1554196200)
(t,o,h,l,c,v) = s.getPrices(5,6)
self.assertEqual(t[-1], 1554195900)
ep = ed + u*(48-len(s.prices[0])+48*0.5+1)
tickEvent = TickEvent(ep, 1, 1)
s.onTick(tickEvent)
self.assertEqual(len(s.prices[0]), 48+48*0.5)
(t,_,_,_,_,_) = s.getPrices()
self.assertEqual(t[-1],ep)
ep = t[-1] + u
tickEvent = TickEvent(ep+100, 1, 1)
s.onTick(tickEvent)
self.assertEqual(len(s.prices[0]), 48)
(t,_,_,_,_,_) = s.getPrices()
self.assertEqual(t[-1],ep)
def _verify(ststr, edstr, tcnt, rcnt, openp, vol):
st = lib.str2epoch(ststr, fmt)
ed = lib.str2epoch(edstr, fmt)
t, o, h, l, c, v = og.getPrice(st, ed)
self.assertEqual(d.countTable(pTable),tcnt)
self.assertEqual(t[0], st)
self.assertEqual(t[-1], ed)
self.assertEqual(len(t), rcnt)
self.assertEqual(v[0], vol)
self.assertEqual(o[0], openp)
def str2epoch_sted(startstr="", endstr=""):
if startstr == "":
startep = -1
else:
startep = lib.str2epoch(startstr, env.DATE_FORMAT_NORMAL)
if endstr == "":
endep = -1
else:
endep = lib.str2epoch(endstr, env.DATE_FORMAT_NORMAL)
return startep, endep
def testWeekends(self):
st = lib.str2epoch("2019/04/19 15:00", "%Y/%m/%d %H:%M")
ed = lib.str2epoch("2019/04/22 03:00", "%Y/%m/%d %H:%M")
d = CheckIndex("USD_JPY", "H1", st, ed)
u = d.unitsecs
from event.tick import TickEvent
t = d.subc.prices[0]
ep = st
eps = []
befwd = []
aftwd1 = []
aftwd2 = []
aftwd3 = []
for i in range(0, len(t)):
ep = t[i]
tickEvent = TickEvent(ep, 1, 1)
d.onTick(tickEvent)
dt = lib.epoch2dt(ep)
eps.append("%d %d" % (dt.day, dt.hour))
befwd.append(d.isNHoursBeforeWeekend(2))
aftwd1.append(d.isNHoursAfterWeekend(1))
aftwd2.append(d.isNHoursAfterWeekend(2))
aftwd3.append(d.isNHoursAfterWeekend(3))
befwd_a = [
True, True, True, False, False, False, False, False, True, True,
True, True, True
]
self.assertListEqual(befwd, befwd_a, "beyond 2h before weekend")
aftwd1_a = [
True, True, True, True, True, False, False, False, False, True,
True, True, True
]
self.assertListEqual(aftwd1, aftwd1_a, "over 1h after weekend")
'''
eps =
['19 15', '19 16', '19 17', '19 18', '19 19',
'19 20', '21 21', '21 22', '21 23', '22 0',
'22 1', '22 2', '22 3']
'''
aftwd2_a = [
True, True, True, True, True, False, False, False, False, False,
True, True, True
]
self.assertListEqual(aftwd2, aftwd2_a, "over 2h after weekend")
aftwd3_a = [
True, True, True, True, True, False, False, False, False, False,
False, True, True
]
self.assertListEqual(aftwd3, aftwd3_a, "over 3h after weekend")
def testGetOandaPrice(self):
st = lib.str2epoch("2019/04/02 09:00", "%Y/%m/%d %H:%M")
ed = lib.str2epoch("2019/04/02 12:00", "%Y/%m/%d %H:%M")
o = OandaGetter("USD_JPY", "H1")
t, o, h, l, c, v = o.getPrice(st, ed)
self.assertEqual(t[0], 1554195600)
self.assertEqual(t[-1], 1554206400)
self.assertEqual(len(t), 4)
self.assertEqual(v[0], 372)
self.assertEqual(o[0], 111.394)
def __init__(self):
self.startep = lib.str2epoch("2019-11-27T17:45:00")
self.endep = lib.str2epoch("2019-11-28T00:25:00")
name = "TestHistIndex"
subc = SubChart(name, "USD_JPY", "M5",
startep=self.startep, endep=self.endep)
super(TestHistIndex, self).__init__("TestHistIndex", subc)
super(HistIndex, self).__init__(name, subc)
subc.onTick(TickEvent(self.endep,0,0,0))
(t,_,_,_,_,_) = subc.getPrices(self.startep, self.endep)
self.subc = subc
for epoch in t:
self.calcHist(epoch)
def testCase1(self):
instrument = "USD_JPY"
granularity = "M5"
st = lib.str2epoch("2019-11-15T00:00:00")
ed = lib.str2epoch("2019-11-15T01:00:00")
testdata.prepare2legData(instrument, granularity, 100.0, st, ed, 3)
testdata.makeSmallPeriodData(instrument, granularity, "M1")
strategy = SimpleMarketStrategy(instrument, granularity, 5)
history = runTestingBacktest("c1", instrument, st, ed, strategy)
res = history[0]
self.assertEqual(res.id, 1, "id")
self.assertEqual(res.epoch, lib.str2epoch("2019-11-15T00:02:00"),
"order start")
self.assertEqual(res.trade_open_time,
lib.str2epoch("2019-11-15T00:03:00"), "trade start")
self.assertEqual(res.trade_close_time,
lib.str2epoch("2019-11-15T00:09:00"), "trade close")
self.assertEqual(res.trade_profit, -0.054, "profit")
res = history[1]
self.assertEqual(res.id, 2, "id")
self.assertEqual(res.epoch, lib.str2epoch("2019-11-15T00:11:00"),
"order start")
res = history[6]
self.assertEqual(res.id, 7, "id")
self.assertEqual(res.epoch, lib.str2epoch("2019-11-15T00:41:00"),
"order start")
self.assertEqual(res.trade_close_time,
lib.str2epoch("2019-11-15T00:57:00"), "trade close")
def compDateWithEventQueue(eq, ids, datestrs, item_name,
date_format=env.DATE_FORMAT_NORMAL):
eps = []
for datestr in datestrs:
eps.append(lib.str2epoch(datestr, date_format))
return compWithEventQueue(eq, ids, eps, item_name)
def testDow(self):
env.run_mode = env.MODE_SIMULATE
st = lib.str2epoch("2019/04/24 00:00", "%Y/%m/%d %H:%M")
ed = lib.str2epoch("2019/04/25 00:00", "%Y/%m/%d %H:%M")
d = CheckIndex("USD_JPY", "H1", st, ed)
u = d.unitsecs
from event.tick import TickEvent
ep = lib.str2epoch("2019/04/24 01:00", "%Y/%m/%d %H:%M")
udow_res = []
ldow_res = []
winl = []
hours = []
dts = []
for _ in range(0, 24):
tickEvent = TickEvent(ep, 1, 1)
d.onTick(tickEvent)
udow_res.append(d.isDowCandle(1))
ldow_res.append(d.isDowCandle(-1))
winl.append(d.isWindowOpen(0.01))
hours.append(d.isHourRange(14, 17))
dts.append(lib.epoch2dt(ep).hour)
self.assertEqual(d.nowidx, d.subc.nowidx)
self.assertEqual(d.now, d.subc.now)
ep += u
hl = np.array(d.subc.prices[2])
ll = np.array(d.subc.prices[3])
u1 = [((hl[i] > hl[i - 1]) and (ll[i] > ll[i - 1]))
for i in range(1, len(hl))]
l1 = [((hl[i] < hl[i - 1]) and (ll[i] < ll[i - 1]))
for i in range(1, len(hl))]
w = [False] * len(winl)
w[20] = True
hr = [False] * len(winl)
hr[13] = True
hr[14] = True
hr[15] = True
hr[16] = True
self.assertListEqual(udow_res, u1, "upper dow")
self.assertListEqual(ldow_res, l1, "down dow")
self.assertListEqual(winl, w, "window open")
self.assertListEqual(hours, hr, "hour range")
def testWeekends(self):
st = lib.str2epoch("2019/04/05 20:00", "%Y/%m/%d %H:%M")
ed = lib.str2epoch("2019/04/08 01:00", "%Y/%m/%d %H:%M")
s = SubChart("testWeekends", "USD_JPY", "H1", st, ed, 5)
u = s.unitsecs
i, now = s.getTime(st + 100)
self.assertEqual(i,5)
self.assertEqual(now,1554494400)
i, now = s.getTime(st + u + 100)
self.assertEqual(i,-1)
i, now = s.getTime(1554670800 -u + 100)
self.assertEqual(i,-1)
i, now = s.getTime(1554670800 + 100)
self.assertEqual(i,6)
self.assertEqual(now,1554670800)
def tick(self):
candles = {}
for price_comp in ["M", "B", "A"]:
params = {
"count": 1,
"granularity": self.granularity,
"price": price_comp
}
req = InstrumentsCandles(instrument=self.instrument, params=params)
self.oandaw.request(req)
if req.response == None:
return None
ds = req.response.get('candles')
if len(ds) == 0:
return None
d = ds[-1]
candles["time"] = d["time"]
if price_comp == "M":
price_name = "mid"
if price_comp == "B":
price_name = "bid"
if price_comp == "A":
price_name = "ask"
candles["volume"] = d["volume"]
candles[price_comp] = d[price_name]
ti = candles["time"].split(".")[0]
newepoch = lib.str2epoch(ti, "%Y-%m-%dT%H:%M:%S")
if newepoch < self.now:
return None
#(t,_,h,l,c,_) = self.dataGetter.getPriceAt(self.pos)
t = newepoch
v = candles["volume"]
p = candles["B"]
(hb, lb, cb) = (float(p["h"]), float(p["l"]), float(p["c"]))
p = candles["A"]
(ha, la, ca) = (float(p["h"]), float(p["l"]), float(p["c"]))
p = candles["M"]
(o, h, l, c) = (float(p["o"]), float(p["h"]), float(p["l"]),
float(p["c"]))
updated = t != self.now
self.now = t
if updated:
return TickEvent(t, (ha + la + ca) / 3, (hb + lb + cb) / 3,
o=o,
h=h,
l=l,
c=c,
v=v)
else:
time.sleep(self.unitsecs / 2)
return None
def testResume(self):
env.run_mode = env.MODE_SIMULATE
st = lib.str2epoch("2019/04/24 00:00", "%Y/%m/%d %H:%M")
ed = lib.str2epoch("2019/04/25 00:00", "%Y/%m/%d %H:%M")
d = CheckIndex("USD_JPY", "H1", st, ed)
u = d.unitsecs
from event.tick import TickEvent
ep = lib.str2epoch("2019/04/24 01:00", "%Y/%m/%d %H:%M")
tickEvent = TickEvent(ep, 1, 1)
d.onTick(tickEvent)
self.assertTrue(d.isNextOK())
d.addForNext(5)
ep += 4 * u
tickEvent = TickEvent(ep, 1, 1)
d.onTick(tickEvent)
self.assertFalse(d.isNextOK())
ep += 1 * u
tickEvent = TickEvent(ep, 1, 1)
d.onTick(tickEvent)
self.assertTrue(d.isNextOK())
d.addForNext(5)
ep += 1 * u
tickEvent = TickEvent(ep, 1, 1)
d.addForNext(3)
ep += 4 * u
tickEvent = TickEvent(ep, 1, 1)
d.onTick(tickEvent)
self.assertFalse(d.isNextOK())
ep += 2 * u
tickEvent = TickEvent(ep, 1, 1)
d.onTick(tickEvent)
self.assertFalse(d.isNextOK())
ep += 1 * u
tickEvent = TickEvent(ep, 1, 1)
d.onTick(tickEvent)
self.assertTrue(d.isNextOK())
def getPrice(self, startep, endep):
errret = ([], [], [], [], [], [])
price = self.priceToGet
endep += 1
candleType = ""
if price == "M":
candleType = "mid"
if price == "B":
candleType = "bid"
if price == "A":
candleType = "ask"
req = InstrumentsCandles(instrument="USD_JPY",
params={
"granularity":
self.granularity,
"from":
lib.epoch2str(startep,
"%Y-%m-%dT%H:%M:%SZ"),
"to":
lib.epoch2str(endep,
"%Y-%m-%dT%H:%M:%SZ"),
"datetime_format":
"UNIX"
})
self.oandaw.request(req)
if req.response == None:
return errret
cdls = req.response.get('candles')
count = len(cdls)
(t, o, h, l, c, v) = self.getIniPriceLists(0, count)
for i in range(count):
cdl = cdls[i]
item = cdl[candleType]
ti = cdl["time"].split(".")[0]
t[i] = lib.str2epoch(ti, "%Y-%m-%dT%H:%M:%S")
v[i] = cdl["volume"]
o[i] = float(item["o"])
h[i] = float(item["h"])
l[i] = float(item["l"])
c[i] = float(item["c"])
return t, o, h, l, c, v
def testCase1(self):
t = TestHistIndex()
print(t)
hist = t.hist
epoch = lib.str2epoch("2019-11-27T18:10:00")
self.assertEqual(hist[epoch][0].pos, const_candles.LINEDIST_ABOVE_NEAR)
epoch = lib.str2epoch("2019-11-27T18:15:00")
self.assertEqual(hist[epoch], None)
epoch = lib.str2epoch("2019-11-27T18:40:00")
self.assertEqual(hist[epoch][0].pos, const_candles.LINEDIST_CROSSED)
epoch = lib.str2epoch("2019-11-27T19:20:00")
self.assertEqual(hist[epoch], None)
epoch = lib.str2epoch("2019-11-27T19:30:00")
self.assertEqual(hist[epoch][0].pos, const_candles.LINEDIST_CROSSED)
epoch = lib.str2epoch("2019-11-27T23:00:00")
self.assertEqual(hist[epoch][0].pos, const_candles.LINEDIST_CROSSED)
self.assertEqual(hist[epoch][1].pos, const_candles.LINEDIST_ABOVE_NEAR)
l = [n] * size
c = [n] * size
v = [n] * size
return (ep, o, h, l, c, v)
if __name__ == "__main__":
import env
from data_getter.oanda import OandaGetter
env.run_mode = env.MODE_UNITTEST
from db.mssql import MSSQLDB
from data_getter.mssql import MSSQLGetter
from data_getter.oanda import OandaGetter
import lib
d = MSSQLDB()
d.execute("drop table if exists USD_JPY_H1_prices;")
d.execute("drop table if exists USD_JPY_H1_metainf;")
og = DataGetter(MSSQLGetter(OandaGetter("USD_JPY", "H1")))
st = lib.str2epoch("2019/04/02 09:00", "%Y/%m/%d %H:%M")
ed = lib.str2epoch("2019/04/02 17:00", "%Y/%m/%d %H:%M")
og.retrievePrice(st, ed)
st = lib.str2epoch("2019/04/02 11:00", "%Y/%m/%d %H:%M")
ed = lib.str2epoch("2019/04/02 13:00", "%Y/%m/%d %H:%M")
(t, o, h, l, c, v) = og.getPrice(st, ed)
print(t)
print(o)
class PandasGetter(DataGetter):
def getPrice(self, startep, endep):
(ep, o, h, l, c, v) = super(PandasGetter,
self).getPrice(startep, endep)
na = np.array([o, h, l, c, v])
d = []
for t in ep:
d.append(lib.epoch2dt(t))
df = pd.DataFrame(na.T, index=d, columns=["o", "h", "l", "c", "v"])
return df
if __name__ == "__main__":
from data_getter.mssql import MSSQLGetter
from data_getter.oanda import OandaGetter
env.run_mode = env.MODE_UNITTEST
og = PandasGetter(MSSQLGetter(OandaGetter("USD_JPY", "H1")))
st = lib.str2epoch("2019/04/02 07:00", "%Y/%m/%d %H:%M")
ed = lib.str2epoch("2019/04/02 12:00", "%Y/%m/%d %H:%M")
og.retrievePrice(st, ed)
df = og.getPrice(st, ed)
print(df)
print("finished")
self.oandaw.request(req)
if req.response == None:
return errret
cdls = req.response.get('candles')
count = len(cdls)
(t, o, h, l, c, v) = self.getIniPriceLists(0, count)
for i in range(count):
cdl = cdls[i]
item = cdl[candleType]
ti = cdl["time"].split(".")[0]
t[i] = lib.str2epoch(ti, "%Y-%m-%dT%H:%M:%S")
v[i] = cdl["volume"]
o[i] = float(item["o"])
h[i] = float(item["h"])
l[i] = float(item["l"])
c[i] = float(item["c"])
return t, o, h, l, c, v
if __name__ == "__main__":
o = OandaGetter("USD_JPY", "M5")
import lib
st = lib.str2epoch("2019/04/04 11:50", "%Y/%m/%d %H:%M")
ed = lib.str2epoch("2019/04/04 12:20", "%Y/%m/%d %H:%M")
t, o, h, l, c, v = o.getPrice(st, ed)
print(t)
print(v)
print(o)
endep=endep,
nbars=peakspan + peaksize * 2,
truncateOld=False)
p = TrendLinesIndex(subc, peaksize, peakspan, analspan, deleteOld=False)
tickEvent = TickEvent(endep, 0, 0, 0)
subc.onTick(tickEvent)
p.onTick(tickEvent)
return p.getPlotElements()
if __name__ == "__main__":
import env
env.run_mode = env.MODE_BACKTESTING
instrument = "USD_JPY"
granularity = "M5"
startep = lib.str2epoch("2019-11-28T00:00:00")
endep = lib.str2epoch("2019-11-29T22:00:00")
pes = run(startep, endep)
#print(pes)
import plotly.offline
plotly.offline.init_notebook_mode()
import lib.charts as m
m.plot(instrument,
granularity,
startep,
endep,
pes,
datetime_display_span="h")
'''
Created on 2019/11/09
@author: kot
'''
import env
import lib
from index.power import PowerIndex
startep = lib.str2epoch("2019-10-17T20:00:00", env.DATE_FORMAT_NORMAL)
endep = lib.str2epoch("2019-10-20T00:00:00", env.DATE_FORMAT_NORMAL)
p = PowerIndex("USD_JPY", "M5", startep, endep, 12)
(t, o, h, l, c, v) = p.subc.prices
for i in range(len(p.epochs)):
bu = p.bull_totals[i]
be = p.bear_totals[i]
print("%s price=%.3f bull_rate=%.3f bull_change=%.3f bear_change=%.3f" %
(lib.epoch2str(p.epochs[i], env.DATE_FORMAT_NORMAL),
c[i + p.sumspan], bu / (bu + be), p.bull[i] / bu, p.bear[i] / be))
'''
Created on 2019/11/30
@author: kot
'''
import lib
from strategy.priceAction import PriceActionStrategy
from lib.backtests import runTestingBacktest
import env
env.run_mode = env.MODE_BACKTESTING
env.loglevel = env.LOGLEVEL_DEBUG
instrument = "USD_JPY"
granularity = "M5"
st = lib.str2epoch("2019-11-28T00:00:00")
ed = lib.str2epoch("2019-11-29T00:00:00")
strategy = PriceActionStrategy(instrument, granularity, st, ed)
history = runTestingBacktest("experiment", instrument, st, ed, strategy)
print("Finish")
def testCase1(self):
instrument = "USD_JPY"
granularity = "M5"
startep = lib.str2epoch("2019-11-12T12:00:00")
endep = lib.str2epoch("2019-11-12T15:00:00")
peakspan = 48
peaksize = 5
subc = SubChart("PeakIndex%d" % peakspan,
instrument,
granularity,
startep,
endep,
nbars=max(peakspan + peaksize * 2 + 1, peakspan * 2))
p = PeakIndex(subc, peaksize, peakspan, peakspan * 2)
# Just after initialization
self.assertEqual(len(p.tops), 4)
self.assertEqual(len(p.bottoms), 6)
self.assertEqual(p.tops[1573548300], 109.266)
self.assertEqual(p.tops[1573553400], 109.205)
self.assertEqual(p.bottoms[1573545600], 109.21)
self.assertEqual(p.bottoms[1573558200], 109.184)
self.assertEqual(len(p.top_trendlines), 2)
self.assertEqual(len(p.bottom_trendlines), 1)
self.assertEqual("%.8f" % p.top_trendlines[1573550700], '-0.00000593')
self.assertEqual("%.8f" % p.top_trendlines[1573548300], '-0.00001196')
self.assertEqual("%.8f" % p.bottom_trendlines[1573554300],
'0.00000769')
self.assertEqual("%.3f" % p.maxs[1573548300], '109.266')
self.assertEqual("%.3f" % p.mins[1573552500], '109.142')
#After tick
epoch = startep + 60
tickEvent = TickEvent(epoch, 0, 0, 0)
subc.onTick(tickEvent)
self.assertFalse(p.onTick(tickEvent))
epoch = startep + 300
tickEvent = TickEvent(epoch, 0, 0, 0)
subc.onTick(tickEvent)
self.assertTrue(p.onTick(tickEvent))
epoch = lib.str2epoch("2019-11-12T14:00:00")
tickEvent = TickEvent(epoch, 0, 0, 0)
subc.onTick(tickEvent)
self.assertTrue(p.onTick(tickEvent))
self.assertEqual(len(p.tops), 5)
self.assertEqual(len(p.bottoms), 6)
self.assertEqual(len(p.top_trendlines), 1)
self.assertEqual(len(p.bottom_trendlines), 3)
self.assertEqual(p.tops[1573553100], 109.205)
self.assertEqual(p.bottoms[1573552500], 109.142)
epoch = lib.str2epoch("2019-11-12T16:00:00")
tickEvent = TickEvent(epoch, 0, 0, 0)
subc.onTick(tickEvent)
self.assertTrue(p.onTick(tickEvent))
self.assertEqual(len(p.tops), 3)
self.assertEqual(len(p.bottoms), 4)
self.assertEqual(len(p.top_trendlines), 2)
self.assertEqual(len(p.bottom_trendlines), 2)
price -= direction * pdiff
elif shuff == 3:
price += direction * pdiff * 2
else:
price += direction * pdiff
ep += sus
#
def prepare2legData(instrument, granularity, startprice, start, end, diffpips):
reCreatePriceTable(instrument, granularity)
midep = (start + end) / 2
unitsecs = tradelib.getUnitSecs(granularity)
insertMonoPricedata(instrument, granularity, startprice, start, midep, 1,
diffpips)
insertMonoPricedata(instrument, granularity, startprice, midep + unitsecs,
end, -1, diffpips)
if __name__ == "__main__":
st = lib.str2epoch("2019-11-01T00:00:00")
ed = lib.str2epoch("2019-11-01T00:30:00")
instrument = "USD_JPY"
granularity = "M5"
granularity2 = "M1"
reCreatePriceTable(instrument, granularity)
reCreatePriceTable(instrument, granularity2)
insertMonoPricedata(instrument, granularity, 100.0, st, ed, -1, 2)
makeSmallPeriodData(instrument, granularity, granularity2)
print("finished")
