def testResample(self):
barDs = bards.BarDataSeries()
resampledDS = resampled_ds.ResampledDataSeries(barDs.getCloseDataSeries(), bar.Frequency.MINUTE, sum)
resampledBarDS = resampled_ds.ResampledBarDataSeries(barDs, bar.Frequency.MINUTE)
barDs.append(bar.BasicBar(datetime.datetime(2011, 1, 1, 1, 1, 1), 2.1, 3, 1, 2, 10, 1, bar.Frequency.SECOND))
barDs.append(bar.BasicBar(datetime.datetime(2011, 1, 1, 1, 1, 2), 2, 3, 1, 2.3, 10, 2, bar.Frequency.SECOND))
barDs.append(bar.BasicBar(datetime.datetime(2011, 1, 1, 1, 2, 1), 2, 3, 1, 2, 10, 2, bar.Frequency.SECOND))
self.assertEqual(len(resampledBarDS), 1)
self.assertEqual(resampledBarDS[0].getDateTime(), datetime.datetime(2011, 1, 1, 1, 1))
self.assertEqual(resampledBarDS[0].getOpen(), 2.1)
self.assertEqual(resampledBarDS[0].getHigh(), 3)
self.assertEqual(resampledBarDS[0].getLow(), 1)
self.assertEqual(resampledBarDS[0].getClose(), 2.3)
self.assertEqual(resampledBarDS[0].getVolume(), 20)
self.assertEqual(resampledBarDS[0].getAdjClose(), 2)
self.assertEqual(resampledDS[-1], 2 + 2.3)
resampledBarDS.pushLast()
self.assertEqual(len(resampledBarDS), 2)
self.assertEqual(resampledBarDS[1].getDateTime(), datetime.datetime(2011, 1, 1, 1, 2))
self.assertEqual(resampledBarDS[1].getOpen(), 2)
self.assertEqual(resampledBarDS[1].getHigh(), 3)
self.assertEqual(resampledBarDS[1].getLow(), 1)
self.assertEqual(resampledBarDS[1].getClose(), 2)
self.assertEqual(resampledBarDS[1].getVolume(), 10)
self.assertEqual(resampledBarDS[1].getAdjClose(), 2)
resampledDS.pushLast()
self.assertEqual(resampledDS[1], 2)
def testInvalidDateTimes(self):
b1 = bar.BasicBar(datetime.datetime.now(), 2, 3, 1, 2.1, 10, 5,
bar.Frequency.DAY)
b2 = bar.BasicBar(datetime.datetime.now() + datetime.timedelta(days=1),
2, 3, 1, 2.1, 10, 5, bar.Frequency.DAY)
with self.assertRaises(Exception):
bar.Bars({"a": b1, "b": b2})
def main():
bf = TestBarFeed(bar.Frequency.DAY)
bars = [
bar.BasicBar(datetime.datetime(2000, 1, 1), 10, 10, 10, 10, 10, 10,
bar.Frequency.DAY),
bar.BasicBar(datetime.datetime(2000, 1, 2), 10, 10, 10, 10, 10, 10,
bar.Frequency.DAY),
]
bf.addBarsFromSequence("orcl", bars)
logger.getLogger().setLevel(logging.DEBUG)
strat = BacktestingStrategy(bf, 1)
strat.run()
def testBasic(self):
dt = datetime.datetime.now()
b1 = bar.BasicBar(dt, 1, 1, 1, 1, 10, 1, bar.Frequency.DAY)
b2 = bar.BasicBar(dt, 2, 2, 2, 2, 10, 2, bar.Frequency.DAY)
bars = bar.Bars({"a": b1, "b": b2})
self.assertEquals(bars["a"].getClose(), 1)
self.assertEquals(bars["b"].getClose(), 2)
self.assertTrue("a" in bars)
self.assertEquals(bars.items(), [("a", b1), ("b", b2)])
self.assertEquals(bars.keys(), ["a", "b"])
self.assertEquals(bars.getInstruments(), ["a", "b"])
self.assertEquals(bars.getDateTime(), dt)
self.assertEquals(bars.getBar("a").getClose(), 1)
def testAppendInvalidDatetime(self):
ds = bards.BarDataSeries()
for i in range(10):
now = datetime.datetime.now() + datetime.timedelta(seconds=i)
ds.append(bar.BasicBar(now, 0, 0, 0, 0, 0, 0,
bar.Frequency.SECOND))
# Adding the same datetime twice should fail
with self.assertRaises(Exception):
ds.append(
bar.BasicBar(now, 0, 0, 0, 0, 0, 0, bar.Frequency.SECOND))
# Adding a previous datetime should fail
with self.assertRaises(Exception):
ds.append(
bar.BasicBar(now - datetime.timedelta(seconds=i), 0, 0, 0,
0, 0, 0, bar.Frequency.SECOND))
def testBaseBarFeedNoAdjClose(self):
bars = [
bar.Bars({
"orcl":
bar.BasicBar(datetime.datetime(2001, 1, 1), 1, 1, 1, 1, 1,
None, bar.Frequency.DAY)
}),
bar.Bars({
"orcl":
bar.BasicBar(datetime.datetime(2001, 1, 2), 1, 1, 1, 1, 1,
None, bar.Frequency.DAY)
}),
]
barFeed = barfeed.OptimizerBarFeed(bar.Frequency.DAY, ["orcl"], bars)
check_base_barfeed(self, barFeed, False)
def getGrouped(self):
"""Return the grouped value."""
ret = bar.BasicBar(self.getDateTime(), self.__open, self.__high,
self.__low, self.__close, self.__volume,
self.__adjClose, self.__frequency)
ret.setUseAdjustedValue(self.__useAdjValue)
return ret
def __buildBar(self, openPrice, highPrice, lowPrice, closePrice):
dateTime = datetime.datetime.now() + datetime.timedelta(
seconds=self.__currSeconds)
self.__currSeconds += 1
return bar.BasicBar(dateTime, openPrice, highPrice, lowPrice,
closePrice, closePrice * 10, closePrice,
bar.Frequency.DAY)
def testInvalidConstruction(self):
with self.assertRaises(Exception):
bar.BasicBar(datetime.datetime.now(), 2, 1, 1, 1, 1, 1,
bar.Frequency.DAY)
with self.assertRaises(Exception):
bar.BasicBar(datetime.datetime.now(), 1, 1, 1, 2, 1, 1,
bar.Frequency.DAY)
with self.assertRaises(Exception):
bar.BasicBar(datetime.datetime.now(), 1, 2, 1.5, 1, 1, 1,
bar.Frequency.DAY)
with self.assertRaises(Exception):
bar.BasicBar(datetime.datetime.now(), 2, 2, 1.5, 1, 1, 1,
bar.Frequency.DAY)
with self.assertRaises(Exception):
bar.BasicBar(datetime.datetime.now(), 1, 1, 1.5, 1, 1, 1,
bar.Frequency.DAY)
def build_bar(barDict, identifier, frequency):
# "StartDate": "3/19/2014"
# "StartTime": "9:55:00 AM"
# "EndDate": "3/19/2014"
# "EndTime": "10:00:00 AM"
# "UTCOffset": 0
# "Open": 31.71
# "High": 31.71
# "Low": 31.68
# "Close": 31.69
# "Volume": 2966
# "Trades": 19
# "TWAP": 31.6929
# "VWAP": 31.693
startDate = barDict["StartDate"]
startTime = barDict["StartTime"]
startDateTimeStr = startDate + " " + startTime
startDateTime = datetime.datetime.strptime(startDateTimeStr,
"%m/%d/%Y %I:%M:%S %p")
instrument, exchange = api.parse_instrument_exchange(identifier)
startDateTime = api.to_market_datetime(startDateTime, exchange)
return bar.BasicBar(startDateTime, barDict["Open"], barDict["High"],
barDict["Low"], barDict["Close"], barDict["Volume"],
None, frequency)
def getBars(self,
instrument,
frequency,
timezone=None,
fromDateTime=None,
toDateTime=None):
instrument = normalize_instrument(instrument)
sql = "select bar.timestamp, bar.open, bar.high, bar.low, bar.close, bar.volume, bar.adj_close, bar.frequency" \
" from bar join instrument on (bar.instrument_id = instrument.instrument_id)" \
" where instrument.name = ? and bar.frequency = ?"
args = [instrument, frequency]
if fromDateTime is not None:
sql += " and bar.timestamp >= ?"
args.append(dt.datetime_to_timestamp(fromDateTime))
if toDateTime is not None:
sql += " and bar.timestamp <= ?"
args.append(dt.datetime_to_timestamp(toDateTime))
sql += " order by bar.timestamp asc"
cursor = self.__connection.cursor()
cursor.execute(sql, args)
ret = []
for row in cursor:
dateTime = dt.timestamp_to_datetime(row[0])
if timezone:
dateTime = dt.localize(dateTime, timezone)
ret.append(
bar.BasicBar(dateTime, row[1], row[2], row[3], row[4], row[5],
row[6], row[7]))
cursor.close()
return ret
def parseBar(self, csvRowDict):
dateTime = self.__parseDateTime(csvRowDict["Date Time"])
close = float(csvRowDict["Close"])
open_ = float(csvRowDict["Open"])
high = float(csvRowDict["High"])
low = float(csvRowDict["Low"])
volume = float(csvRowDict["Volume"])
return bar.BasicBar(dateTime, open_, high, low, close, volume, None,
self.__frequency)
def testDateTimesNotInOrder(self):
bars = [
bar.Bars({
"orcl":
bar.BasicBar(datetime.datetime(2001, 1, 2), 1, 1, 1, 1, 1, 1,
bar.Frequency.DAY)
}),
bar.Bars({
"orcl":
bar.BasicBar(datetime.datetime(2001, 1, 1), 1, 1, 1, 1, 1, 1,
bar.Frequency.DAY)
}),
]
f = barfeed.OptimizerBarFeed(bar.Frequency.DAY, ["orcl"], bars)
with self.assertRaisesRegexp(Exception,
"Bar date times are not in order.*"):
for dt, b in f:
pass
def testNonEmpty(self):
ds = bards.BarDataSeries()
for i in range(10):
ds.append(
bar.BasicBar(
datetime.datetime.now() + datetime.timedelta(seconds=i), 0,
0, 0, 0, 0, 0, bar.Frequency.SECOND))
for i in range(0, 10):
self.assertTrue(ds[i].getOpen() == 0)
def main():
bf = TestBarFeed(bar.Frequency.DAY)
bars = [
bar.BasicBar(datetime.datetime(2000, 1, 1), 10, 10, 10, 10, 10, 10,
bar.Frequency.DAY),
]
bf.addBarsFromSequence("orcl", bars)
strat = Strategy(bf, 1000)
strat.run()
def build_bars_from_closing_prices(closingPrices):
ret = []
nextDateTime = datetime.datetime.now()
for closePrice in closingPrices:
bar_ = bar.BasicBar(nextDateTime, closePrice, closePrice, closePrice,
closePrice, closePrice, closePrice,
bar.Frequency.DAY)
ret.append(bar_)
nextDateTime = nextDateTime + datetime.timedelta(days=1)
return ret
def testDateTimes(self):
ds = bards.BarDataSeries()
firstDt = datetime.datetime.now()
for i in range(10):
ds.append(
bar.BasicBar(firstDt + datetime.timedelta(seconds=i), 2, 4, 1,
3, 10, 3, bar.Frequency.SECOND))
for i in range(10):
self.assertEqual(ds[i].getDateTime(), ds.getDateTimes()[i])
self.assertEqual(ds.getDateTimes()[i],
firstDt + datetime.timedelta(seconds=i))
def __loadSarTestBarDs(self):
seconds = 0
ret = bards.BarDataSeries()
for i in xrange(len(SAR_HIGH)):
dateTime = datetime.datetime.now() + datetime.timedelta(
seconds=seconds)
ret.append(
bar.BasicBar(dateTime, SAR_LOW[i], SAR_HIGH[i], SAR_LOW[i],
SAR_HIGH[i], 0, SAR_LOW[i], bar.Frequency.DAY))
seconds += 1
return ret
def __loadBarDS(self):
seconds = 0
ret = bards.BarDataSeries()
for i in xrange(len(OPEN_VALUES)):
dateTime = datetime.datetime.now() + datetime.timedelta(
seconds=seconds)
ret.append(
bar.BasicBar(dateTime, OPEN_VALUES[i], HIGH_VALUES[i],
LOW_VALUES[i], CLOSE_VALUES[i], VOLUME_VALUES[i],
CLOSE_VALUES[i], bar.Frequency.DAY))
seconds += 1
return ret
def testNoAdjClose(self):
b = bar.BasicBar(datetime.datetime.now(), 2, 3, 1, 2.1, 10, None,
bar.Frequency.DAY)
with self.assertRaises(Exception):
b.setUseAdjustedValue(True)
with self.assertRaises(Exception):
b.getOpen(True)
with self.assertRaises(Exception):
b.getHigh(True)
with self.assertRaises(Exception):
b.getLow(True)
with self.assertRaises(Exception):
b.getClose(True)
def testSeqLikeOps(self):
seq = []
ds = bards.BarDataSeries()
for i in range(10):
bar_ = bar.BasicBar(
datetime.datetime.now() + datetime.timedelta(seconds=i), 2, 4,
1, 3, 10, 3, bar.Frequency.SECOND)
ds.append(bar_)
seq.append(bar_)
self.assertEqual(ds[-1], seq[-1])
self.assertEqual(ds[-2], seq[-2])
self.assertEqual(ds[0], seq[0])
self.assertEqual(ds[1], seq[1])
self.assertEqual(ds[-2:][-1], seq[-2:][-1])
def testStockChartsATR(self):
# Test data from http://stockcharts.com/help/doku.php?id=chart_school:technical_indicators:average_true_range_a
high = [48.70, 48.72, 48.90, 48.87, 48.82, 49.05, 49.20, 49.35, 49.92, 50.19, 50.12, 49.66, 49.88, 50.19, 50.36, 50.57, 50.65, 50.43, 49.63, 50.33, 50.29, 50.17, 49.32, 48.50, 48.32, 46.80, 47.80, 48.39, 48.66, 48.79]
low = [47.790, 48.140, 48.390, 48.370, 48.240, 48.635, 48.940, 48.860, 49.500, 49.870, 49.200, 48.900, 49.430, 49.725, 49.260, 50.090, 50.300, 49.210, 48.980, 49.610, 49.200, 49.430, 48.080, 47.640, 41.550, 44.283, 47.310, 47.200, 47.900, 47.730]
close = [48.160, 48.610, 48.750, 48.630, 48.740, 49.030, 49.070, 49.320, 49.910, 50.130, 49.530, 49.500, 49.750, 50.030, 50.310, 50.520, 50.410, 49.340, 49.370, 50.230, 49.238, 49.930, 48.430, 48.180, 46.570, 45.410, 47.770, 47.720, 48.620, 47.850]
expected = [None, None, None, None, None, None, None, None, None, None, None, None, None, 0.56, 0.59, 0.59, 0.57, 0.62, 0.62, 0.64, 0.67, 0.69, 0.78, 0.78, 1.21, 1.30, 1.38, 1.37, 1.34, 1.32]
# Build a bar dataseries using the test data.
barDataSeries = bards.BarDataSeries()
atrDS = atr.ATR(barDataSeries, 14)
now = datetime.datetime(2000, 1, 1)
for i in xrange(len(high)):
b = bar.BasicBar(now + datetime.timedelta(days=i), close[i], high[i], low[i], close[i], 100, close[i], bar.Frequency.DAY)
barDataSeries.append(b)
self.assertEqual(common.safe_round(atrDS[-1], 2), expected[i])
def testNestedDataSeries(self):
ds = bards.BarDataSeries()
for i in range(10):
ds.append(
bar.BasicBar(
datetime.datetime.now() + datetime.timedelta(seconds=i), 2,
4, 1, 3, 10, 3, bar.Frequency.SECOND))
self.__testGetValue(ds.getOpenDataSeries(), 10, 2)
self.__testGetValue(ds.getCloseDataSeries(), 10, 3)
self.__testGetValue(ds.getHighDataSeries(), 10, 4)
self.__testGetValue(ds.getLowDataSeries(), 10, 1)
self.__testGetValue(ds.getVolumeDataSeries(), 10, 10)
self.__testGetValue(ds.getAdjCloseDataSeries(), 10, 3)
self.__testGetValue(ds.getPriceDataSeries(), 10, 3)
def parseBar(self, csvRowDict):
dateTime = self.__parseDate(csvRowDict["Date"])
close = float(csvRowDict["Close"])
open_ = float(csvRowDict["Open"])
high = float(csvRowDict["High"])
low = float(csvRowDict["Low"])
volume = float(csvRowDict["Volume"])
adjClose = None
if self.__sanitize:
open_, high, low, close = common.sanitize_ohlc(
open_, high, low, close)
return bar.BasicBar(dateTime, open_, high, low, close, volume,
adjClose, self.__frequency)
def testCheckNow(self):
barDs = bards.BarDataSeries()
resampledBarDS = resampled_ds.ResampledBarDataSeries(barDs, bar.Frequency.MINUTE)
barDateTime = datetime.datetime(2014, 07, 07, 22, 46, 28, 10000)
barDs.append(bar.BasicBar(barDateTime, 2.1, 3, 1, 2, 10, 1, bar.Frequency.MINUTE))
self.assertEqual(len(resampledBarDS), 0)
resampledBarDS.checkNow(barDateTime + datetime.timedelta(minutes=1))
self.assertEqual(len(resampledBarDS), 1)
self.assertEqual(barDs[0].getOpen(), resampledBarDS[0].getOpen())
self.assertEqual(barDs[0].getHigh(), resampledBarDS[0].getHigh())
self.assertEqual(barDs[0].getLow(), resampledBarDS[0].getLow())
self.assertEqual(barDs[0].getClose(), resampledBarDS[0].getClose())
self.assertEqual(barDs[0].getVolume(), resampledBarDS[0].getVolume())
self.assertEqual(barDs[0].getAdjClose(), resampledBarDS[0].getAdjClose())
self.assertEqual(resampledBarDS[0].getDateTime(), datetime.datetime(2014, 07, 07, 22, 46))
def testPickle(self):
b1 = bar.BasicBar(datetime.datetime.now(), 2, 3, 1, 2.1, 10, 5,
bar.Frequency.DAY)
b2 = cPickle.loads(cPickle.dumps(b1))
self.assertEquals(b1.getDateTime(), b2.getDateTime())
self.assertEquals(b1.getOpen(), b2.getOpen())
self.assertEquals(b1.getHigh(), b2.getHigh())
self.assertEquals(b1.getLow(), b2.getLow())
self.assertEquals(b1.getClose(), b2.getClose())
self.assertEquals(b1.getVolume(), b2.getVolume())
self.assertEquals(b1.getAdjClose(), b2.getAdjClose())
self.assertEquals(b1.getFrequency(), b2.getFrequency())
self.assertEquals(b1.getPrice(), b2.getPrice())
self.assertEquals(b1.getOpen(True), b2.getOpen(True))
self.assertEquals(b1.getHigh(True), b2.getHigh(True))
self.assertEquals(b1.getLow(True), b2.getLow(True))
self.assertEquals(b1.getClose(True), b2.getClose(True))
def testTypicalPrice(self):
b = bar.BasicBar(datetime.datetime.now(), 2, 3, 1, 2.1, 10, 5,
bar.Frequency.DAY)
self.assertEquals(b.getTypicalPrice(), (3 + 1 + 2.1) / 3)
def testGetPrice(self):
b = bar.BasicBar(datetime.datetime.now(), 2, 3, 1, 2.1, 10, 5,
bar.Frequency.DAY)
self.assertEquals(b.getPrice(), b.getClose())
b.setUseAdjustedValue(True)
self.assertEquals(b.getPrice(), b.getAdjClose())
