def testReSubmit(self): brk = backtesting.Broker(15, barFeed=barfeed.BarFeed(barfeed.Frequency.MINUTE)) # Buy. Stop >= 10. Buy <= 12. cb = Callback() brk.getOrderUpdatedEvent().subscribe(cb.onOrderUpdated) order = brk.createStopLimitOrder(broker.Order.Action.BUY, BaseTestCase.TestInstrument, stopPrice=1, limitPrice=1, quantity=1) brk.placeOrder(order) order.setLimitPrice(12) brk.placeOrder(order) order.setStopPrice(10) brk.placeOrder(order) # Stop price not hit. Limit price not hit. brk.onBars(self.buildBars(8, 9, 7, 8)) self.assertFalse(order.isLimitOrderActive()) self.assertTrue(order.isAccepted()) # Stop price hit. Limit price not hit. brk.onBars(self.buildBars(13, 15, 13, 14)) self.assertTrue(order.isLimitOrderActive()) self.assertTrue(order.isAccepted()) # Limit price hit (bars include the price). Fill at open price. brk.onBars(self.buildBars(11, 15, 10, 14)) self.assertTrue(order.isLimitOrderActive()) self.assertTrue(order.isFilled()) self.assertTrue(order.getExecutionInfo().getPrice() == 11)
def testBuyAndSell(self): brk = backtesting.Broker(11, barFeed=barfeed.BarFeed(barfeed.Frequency.MINUTE)) # Buy cb = Callback() brk.getOrderUpdatedEvent().subscribe(cb.onOrderUpdated) order = brk.createMarketOrder(broker.Order.Action.BUY, BaseTestCase.TestInstrument, 1) brk.placeOrder(order) brk.onBars(self.buildBars(10, 15, 8, 12)) self.assertTrue(order.isFilled()) self.assertTrue(order.getExecutionInfo().getPrice() == 10) self.assertTrue(order.getExecutionInfo().getCommission() == 0) self.assertTrue(len(brk.getActiveOrders()) == 0) self.assertTrue(brk.getCash() == 1) self.assertTrue(brk.getShares(BaseTestCase.TestInstrument) == 1) self.assertTrue(cb.eventCount == 2) # Sell cb = Callback() brk.getOrderUpdatedEvent().subscribe(cb.onOrderUpdated) order = brk.createMarketOrder(broker.Order.Action.SELL, BaseTestCase.TestInstrument, 1) brk.placeOrder(order) brk.onBars(self.buildBars(10, 15, 8, 12)) self.assertTrue(order.isFilled()) self.assertTrue(order.getExecutionInfo().getPrice() == 10) self.assertTrue(order.getExecutionInfo().getCommission() == 0) self.assertTrue(len(brk.getActiveOrders()) == 0) self.assertTrue(brk.getCash() == 11) self.assertTrue(brk.getShares(BaseTestCase.TestInstrument) == 0) self.assertTrue(cb.eventCount == 2)
def testBuyAndSellInTwoSteps(self): brk = backtesting.Broker(20.4, barFeed=barfeed.BarFeed(barfeed.Frequency.MINUTE)) # Buy order = brk.createMarketOrder(broker.Order.Action.BUY, BaseTestCase.TestInstrument, 2) brk.placeOrder(order) brk.onBars(self.buildBars(10, 15, 8, 12)) self.assertTrue(order.isFilled()) self.assertTrue(order.getExecutionInfo().getPrice() == 10) self.assertTrue(order.getExecutionInfo().getCommission() == 0) self.assertTrue(len(brk.getActiveOrders()) == 0) self.assertTrue(round(brk.getCash(), 1) == 0.4) self.assertTrue(brk.getShares(BaseTestCase.TestInstrument) == 2) # Sell order = brk.createMarketOrder(broker.Order.Action.SELL, BaseTestCase.TestInstrument, 1) brk.placeOrder(order) brk.onBars(self.buildBars(10, 15, 8, 12)) self.assertTrue(order.isFilled()) self.assertTrue(order.getExecutionInfo().getPrice() == 10) self.assertTrue(order.getExecutionInfo().getCommission() == 0) self.assertTrue(len(brk.getActiveOrders()) == 0) self.assertTrue(round(brk.getCash(), 1) == 10.4) self.assertTrue(brk.getShares(BaseTestCase.TestInstrument) == 1) # Sell again order = brk.createMarketOrder(broker.Order.Action.SELL, BaseTestCase.TestInstrument, 1) brk.placeOrder(order) brk.onBars(self.buildBars(11, 15, 8, 12)) self.assertTrue(order.isFilled()) self.assertTrue(order.getExecutionInfo().getPrice() == 11) self.assertTrue(order.getExecutionInfo().getCommission() == 0) self.assertTrue(len(brk.getActiveOrders()) == 0) self.assertTrue(round(brk.getCash(), 1) == 21.4) self.assertTrue(brk.getShares(BaseTestCase.TestInstrument) == 0)
def run_strategy(fastSma, slowSma, tp, stop):
# Load the bar feed from the CSV file
feed = csvfeed.GenericBarFeed(frequency=60 * 5)
feed.setDateTimeFormat("%Y-%m-%dT%H:%M:%S.%fZ")
feed.addBarsFromCSV("btc", "btc-5m-apr.csv")
# Create our broker defining the comission(0,01%) and the initial balance($15000)
commission = backtesting.TradePercentage(0.0001)
broker = backtesting.Broker(15000, feed, commission)
# Evaluate the strategy with the feed
myStrategy = MACrossoverStrategy(feed, "btc", broker, fastSma, slowSma, tp,
stop)
# Attach the plotter to the strategy
plt = plotter.StrategyPlotter(myStrategy)
# Include the MA in the instrument's subplot to get it displayed along with the closing prices
plt.getOrCreateSubplot("MA").addDataSeries("50 MA",
myStrategy.getFastSMA())
plt.getOrCreateSubplot("MA").addDataSeries("200 MA",
myStrategy.getSlowSMA())
# Run the strategy and show the final portfolio value
myStrategy.run()
myStrategy.info(f'Final portfolio value: ${myStrategy.getResult()}')
# Plot the strategy
plt.plot()
def __init__(self, barFeed, cash=1000000):
# The broker should subscribe to barFeed events before the strategy.
# This is to avoid executing orders placed in the current tick.
broker = backtesting.Broker(cash, barFeed)
BaseStrategy.__init__(self, barFeed, broker)
self.__useAdjustedValues = False
self.setUseEventDateTimeInLogs(True)
def testHitStopAndLimit(self): brk = backtesting.Broker(15, barFeed=barfeed.BarFeed(barfeed.Frequency.MINUTE)) # Buy. Stop >= 10. Buy <= 12. cb = Callback() brk.getOrderUpdatedEvent().subscribe(cb.onOrderUpdated) order = brk.createStopLimitOrder(broker.Order.Action.BUY, BaseTestCase.TestInstrument, stopPrice=10, limitPrice=12, quantity=1) brk.placeOrder(order) # Stop price hit. Limit price hit. Fill at stop price. brk.onBars(self.buildBars(9, 15, 8, 14)) self.assertTrue(order.isLimitOrderActive()) self.assertTrue(order.isFilled()) self.assertTrue(order.getExecutionInfo().getPrice() == 10) # Sell. Stop <= 8. Sell >= 6. cb = Callback() brk.getOrderUpdatedEvent().subscribe(cb.onOrderUpdated) order = brk.createStopLimitOrder(broker.Order.Action.SELL, BaseTestCase.TestInstrument, stopPrice=8, limitPrice=6, quantity=1) brk.placeOrder(order) # Stop price hit. Limit price hit. Fill at stop price. brk.onBars(self.buildBars(9, 10, 5, 8)) self.assertTrue(order.isLimitOrderActive()) self.assertTrue(order.isFilled()) self.assertTrue(order.getExecutionInfo().getPrice() == 8)
def testStrategy():
strat = LiveDemo_run
liveFeed = tushareLiveFeed.LiveFeed(['600848'], '5', preload_start='2017-01-01')
brk = backtesting.Broker(1000,liveFeed)
strat = strat(liveFeed, brk,['600848'],3)
strat.run()
def main(plot):
symbol = "yhoo"
priceCurrency = "USD"
instrument = "%s/%s" % (symbol, priceCurrency)
bBandsPeriod = 40
# Download the bars.
feed = quandl.build_feed("WIKI", [symbol], priceCurrency, 2011, 2012, ".")
broker = backtesting.Broker({priceCurrency: 1000000}, feed)
strat = BBands(feed, broker, instrument, bBandsPeriod)
sharpeRatioAnalyzer = sharpe.SharpeRatio(priceCurrency)
strat.attachAnalyzer(sharpeRatioAnalyzer)
if plot:
from pyalgotrade import plotter
plt = plotter.StrategyPlotter(strat, True, True, True)
plt.getInstrumentSubplot(instrument).addDataSeries("upper", strat.getBollingerBands().getUpperBand())
plt.getInstrumentSubplot(instrument).addDataSeries("middle", strat.getBollingerBands().getMiddleBand())
plt.getInstrumentSubplot(instrument).addDataSeries("lower", strat.getBollingerBands().getLowerBand())
strat.run()
print("Sharpe ratio: %.2f" % sharpeRatioAnalyzer.getSharpeRatio(0.05))
if plot:
plt.plot()
def testCancel(self): brk = backtesting.Broker(100, barFeed=barfeed.BarFeed(barfeed.Frequency.MINUTE)) order = brk.createMarketOrder(broker.Order.Action.BUY, BaseTestCase.TestInstrument, 1) brk.placeOrder(order) brk.cancelOrder(order) brk.onBars(self.buildBars(10, 10, 10, 10)) self.assertTrue(order.isCanceled())
def testSellShort_3(self): brk = backtesting.Broker(100, barFeed=barfeed.BarFeed(barfeed.Frequency.MINUTE)) # Buy 1 order = brk.createMarketOrder(broker.Order.Action.BUY, BaseTestCase.TestInstrument, 1) brk.placeOrder(order) brk.onBars(self.buildBars(100, 100, 100, 100)) self.assertTrue(order.isFilled()) self.assertTrue(order.getExecutionInfo().getCommission() == 0) self.assertTrue(brk.getShares(BaseTestCase.TestInstrument) == 1) self.assertTrue(brk.getCash() == 0) # Sell 2 order = brk.createMarketOrder(broker.Order.Action.SELL_SHORT, BaseTestCase.TestInstrument, 2) brk.placeOrder(order) brk.onBars(self.buildBars(100, 100, 100, 100)) self.assertTrue(order.isFilled()) self.assertTrue(order.getExecutionInfo().getCommission() == 0) self.assertTrue(brk.getShares(BaseTestCase.TestInstrument) == -1) self.assertTrue(brk.getCash() == 200) # Buy 1 order = brk.createMarketOrder(broker.Order.Action.BUY_TO_COVER, BaseTestCase.TestInstrument, 1) brk.placeOrder(order) brk.onBars(self.buildBars(100, 100, 100, 100)) self.assertTrue(order.isFilled()) self.assertTrue(order.getExecutionInfo().getCommission() == 0) self.assertTrue(brk.getShares(BaseTestCase.TestInstrument) == 0) self.assertTrue(brk.getCash() == 100)
def testSellShort_1(self): brk = backtesting.Broker(1000, barFeed=barfeed.BarFeed(barfeed.Frequency.MINUTE)) # Short sell order = brk.createMarketOrder(broker.Order.Action.SELL_SHORT, BaseTestCase.TestInstrument, 1) brk.placeOrder(order) brk.onBars(self.buildBars(200, 200, 200, 200)) self.assertTrue(order.isFilled()) self.assertTrue(order.getExecutionInfo().getCommission() == 0) self.assertTrue(len(brk.getActiveOrders()) == 0) self.assertTrue(brk.getCash() == 1200) self.assertTrue(brk.getShares(BaseTestCase.TestInstrument) == -1) self.assertTrue(brk.getEquityWithBars(self.buildBars(100, 100, 100, 100)) == 1000 + 100) self.assertTrue(brk.getEquityWithBars(self.buildBars(0, 0, 0, 0)) == 1000 + 200) self.assertTrue(brk.getEquityWithBars(self.buildBars(30, 30, 30, 30)) == 1000 + 170) # Buy at the same price. order = brk.createMarketOrder(broker.Order.Action.BUY_TO_COVER, BaseTestCase.TestInstrument, 1) brk.placeOrder(order) brk.onBars(self.buildBars(200, 200, 200, 200)) self.assertTrue(order.isFilled()) self.assertTrue(order.getExecutionInfo().getCommission() == 0) self.assertTrue(len(brk.getActiveOrders()) == 0) self.assertTrue(brk.getCash() == 1000) self.assertTrue(brk.getShares(BaseTestCase.TestInstrument) == 0)
def testSellShort_2(self): brk = backtesting.Broker(1000, barFeed=barfeed.BarFeed(barfeed.Frequency.MINUTE)) # Short sell 1 order = brk.createMarketOrder(broker.Order.Action.SELL_SHORT, BaseTestCase.TestInstrument, 1) brk.placeOrder(order) brk.onBars(self.buildBars(100, 100, 100, 100)) self.assertTrue(order.isFilled()) self.assertTrue(order.getExecutionInfo().getCommission() == 0) self.assertTrue(brk.getCash() == 1100) self.assertTrue(brk.getShares(BaseTestCase.TestInstrument) == -1) self.assertTrue(brk.getEquityWithBars(self.buildBars(100, 100, 100, 100)) == 1000) self.assertTrue(brk.getEquityWithBars(self.buildBars(0, 0, 0, 0)) == 1000 + 100) self.assertTrue(brk.getEquityWithBars(self.buildBars(70, 70, 70, 70)) == 1000 + 30) self.assertTrue(brk.getEquityWithBars(self.buildBars(200, 200, 200, 200)) == 1000 - 100) # Buy 2 and earn 50 order = brk.createMarketOrder(broker.Order.Action.BUY_TO_COVER, BaseTestCase.TestInstrument, 2) brk.placeOrder(order) brk.onBars(self.buildBars(50, 50, 50, 50)) self.assertTrue(order.isFilled()) self.assertTrue(order.getExecutionInfo().getCommission() == 0) self.assertTrue(brk.getShares(BaseTestCase.TestInstrument) == 1) self.assertTrue(brk.getCash() == 1000) # +50 from short sell operation, -50 from buy operation. self.assertTrue(brk.getEquityWithBars(self.buildBars(50, 50, 50, 50)) == 1000 + 50) self.assertTrue(brk.getEquityWithBars(self.buildBars(70, 70, 70, 70)) == 1000 + 50 + 20) # Sell 1 and earn 50 order = brk.createMarketOrder(broker.Order.Action.SELL, BaseTestCase.TestInstrument, 1) brk.placeOrder(order) brk.onBars(self.buildBars(100, 100, 100, 100)) self.assertTrue(order.isFilled()) self.assertTrue(order.getExecutionInfo().getCommission() == 0) self.assertTrue(brk.getShares(BaseTestCase.TestInstrument) == 0) self.assertTrue(brk.getEquityWithBars(self.buildBars(70, 70, 70, 70)) == 1000 + 50 + 50)
def testIGE_BrokerWithCommission(self):
# This testcase is based on an example from Ernie Chan's book:
# 'Quantitative Trading: How to Build Your Own Algorithmic Trading Business'
barFeed = yahoofeed.Feed()
barFeed.addBarsFromCSV(
"ige", common.get_data_file_path("sharpe-ratio-test-ige.csv"))
brk = backtesting.Broker(1000, barFeed, broker.FixedCommission(0.5))
strat = strategy_test.TestStrategy(barFeed, 1000, brk)
strat.getBroker().setUseAdjustedValues(True)
strat.setBrokerOrdersGTC(True)
stratAnalyzer = sharpe.SharpeRatio()
strat.attachAnalyzer(stratAnalyzer)
# Manually place the order to get it filled on the first bar.
order = strat.getBroker().createMarketOrder(broker.Order.Action.BUY,
"ige", 1,
True) # Adj. Close: 42.09
order.setGoodTillCanceled(True)
strat.getBroker().placeOrder(order)
strat.addOrder(datetime.datetime(2007, 11, 13),
strat.getBroker().createMarketOrder,
broker.Order.Action.SELL, "ige", 1,
True) # Adj. Close: 127.64
strat.run()
self.assertTrue(
round(strat.getBroker().getCash(), 2) == 1000 +
(127.64 - 42.09 - 0.5 * 2))
self.assertTrue(strat.getOrderUpdatedEvents() == 2)
# The results are slightly different different only because I'm taking into account the first bar as well,
# and I'm also adding commissions.
self.assertTrue(
round(stratAnalyzer.getSharpeRatio(0.04, 252, annualized=True), 4)
== 0.7763)
def testFailToBuy(self): brk = backtesting.Broker(5, barFeed=barfeed.BarFeed(barfeed.Frequency.MINUTE)) order = brk.createLimitOrder(broker.Order.Action.BUY, BaseTestCase.TestInstrument, 5, 1) # Fail to buy (couldn't get specific price). cb = Callback() brk.getOrderUpdatedEvent().subscribe(cb.onOrderUpdated) brk.placeOrder(order) brk.onBars(self.buildBars(10, 15, 8, 12)) self.assertTrue(order.isAccepted()) self.assertTrue(order.getExecutionInfo() == None) self.assertTrue(len(brk.getActiveOrders()) == 1) self.assertTrue(brk.getCash() == 5) self.assertTrue(brk.getShares(BaseTestCase.TestInstrument) == 0) self.assertTrue(cb.eventCount == 1) # Fail to buy (couldn't get specific price). Canceled due to session close. cb = Callback() brk.getOrderUpdatedEvent().subscribe(cb.onOrderUpdated) brk.onBars(self.buildBars(11, 15, 8, 12, True)) self.assertTrue(order.isCanceled()) self.assertTrue(order.getExecutionInfo() == None) self.assertTrue(len(brk.getActiveOrders()) == 0) self.assertTrue(brk.getCash() == 5) self.assertTrue(brk.getShares(BaseTestCase.TestInstrument) == 0) self.assertTrue(cb.eventCount == 1)
def testBuy_GTC(self): brk = backtesting.Broker(10, barFeed=barfeed.BarFeed(barfeed.Frequency.MINUTE)) order = brk.createLimitOrder(broker.Order.Action.BUY, BaseTestCase.TestInstrument, 4, 2) order.setGoodTillCanceled(True) # Fail to buy (couldn't get specific price). cb = Callback() brk.getOrderUpdatedEvent().subscribe(cb.onOrderUpdated) brk.placeOrder(order) # Set sessionClose to true test that the order doesn't get canceled. brk.onBars(self.buildBars(10, 15, 8, 12, True)) self.assertTrue(order.isAccepted()) self.assertTrue(order.getExecutionInfo() == None) self.assertTrue(len(brk.getActiveOrders()) == 1) self.assertTrue(brk.getCash() == 10) self.assertTrue(brk.getShares(BaseTestCase.TestInstrument) == 0) self.assertTrue(cb.eventCount == 1) # Buy cb = Callback() brk.getOrderUpdatedEvent().subscribe(cb.onOrderUpdated) brk.onBars(self.buildBars(2, 15, 1, 12)) self.assertTrue(order.isFilled()) self.assertTrue(order.getExecutionInfo().getPrice() == 2) self.assertTrue(len(brk.getActiveOrders()) == 0) self.assertTrue(brk.getCash() == 6) self.assertTrue(brk.getShares(BaseTestCase.TestInstrument) == 2) self.assertTrue(cb.eventCount == 1)
def testStrategy():
strat = TickLiveDemo_run
liveFeed = tushareTickLiveFeed.LiveFeed(['600848'], TUSHARE_INQUERY_PERIOD=3)
brk = backtesting.Broker(1000,liveFeed)
strat = strat(liveFeed, brk,['600848'],3)
strat.run()
def testBuyAndSell_GappingBars(self): brk = backtesting.Broker(20, barFeed=barfeed.BarFeed(barfeed.Frequency.MINUTE)) # Buy. Bar is below the target price. cb = Callback() brk.getOrderUpdatedEvent().subscribe(cb.onOrderUpdated) order = brk.createLimitOrder(broker.Order.Action.BUY, BaseTestCase.TestInstrument, 20, 1) brk.placeOrder(order) brk.onBars(self.buildBars(10, 15, 8, 10)) self.assertTrue(order.isFilled()) self.assertTrue(order.getExecutionInfo().getPrice() == 10) self.assertTrue(order.getExecutionInfo().getCommission() == 0) self.assertTrue(len(brk.getActiveOrders()) == 0) self.assertTrue(brk.getCash() == 10) self.assertTrue(brk.getShares(BaseTestCase.TestInstrument) == 1) self.assertTrue(cb.eventCount == 2) # Sell. Bar is above the target price. cb = Callback() brk.getOrderUpdatedEvent().subscribe(cb.onOrderUpdated) order = brk.createLimitOrder(broker.Order.Action.SELL, BaseTestCase.TestInstrument, 30, 1) brk.placeOrder(order) brk.onBars(self.buildBars(35, 40, 32, 35)) self.assertTrue(order.isFilled()) self.assertTrue(order.getExecutionInfo().getPrice() == 35) self.assertTrue(order.getExecutionInfo().getCommission() == 0) self.assertTrue(len(brk.getActiveOrders()) == 0) self.assertTrue(brk.getCash() == 45) self.assertTrue(brk.getShares(BaseTestCase.TestInstrument) == 0) self.assertTrue(cb.eventCount == 2)
def testLongPosStopLoss_GappingBars(self): brk = backtesting.Broker(15, barFeed=barfeed.BarFeed(barfeed.Frequency.MINUTE)) # Buy cb = Callback() brk.getOrderUpdatedEvent().subscribe(cb.onOrderUpdated) order = brk.createMarketOrder(broker.Order.Action.BUY, BaseTestCase.TestInstrument, 1) brk.placeOrder(order) brk.onBars(self.buildBars(10, 15, 8, 12)) self.assertTrue(order.isFilled()) self.assertTrue(order.getExecutionInfo().getPrice() == 10) self.assertTrue(order.getExecutionInfo().getCommission() == 0) self.assertTrue(len(brk.getActiveOrders()) == 0) self.assertTrue(brk.getCash() == 5) self.assertTrue(brk.getShares(BaseTestCase.TestInstrument) == 1) self.assertTrue(cb.eventCount == 2) # Create stop loss order. cb = Callback() brk.getOrderUpdatedEvent().subscribe(cb.onOrderUpdated) order = brk.createStopOrder(broker.Order.Action.SELL, BaseTestCase.TestInstrument, 9, 1) brk.placeOrder(order) brk.onBars(self.buildBars(10, 15, 10, 12)) # Stop loss not hit. self.assertFalse(order.isFilled()) self.assertTrue(len(brk.getActiveOrders()) == 1) self.assertTrue(brk.getCash() == 5) self.assertTrue(brk.getShares(BaseTestCase.TestInstrument) == 1) self.assertTrue(cb.eventCount == 1) brk.onBars(self.buildBars(5, 8, 4, 7)) # Stop loss hit. self.assertTrue(order.isFilled()) self.assertTrue(order.getExecutionInfo().getPrice() == 5) self.assertTrue(len(brk.getActiveOrders()) == 0) self.assertTrue(brk.getCash() == 5+5) # Fill the stop loss order at open price. self.assertTrue(brk.getShares(BaseTestCase.TestInstrument) == 0) self.assertTrue(cb.eventCount == 2)
def testShortPosStopLoss_GappingBars(self): brk = backtesting.Broker(15, barFeed=barfeed.BarFeed(barfeed.Frequency.MINUTE)) # Sell short cb = Callback() brk.getOrderUpdatedEvent().subscribe(cb.onOrderUpdated) order = brk.createMarketOrder(broker.Order.Action.SELL_SHORT, BaseTestCase.TestInstrument, 1) brk.placeOrder(order) brk.onBars(self.buildBars(10, 15, 8, 12)) self.assertTrue(order.isFilled()) self.assertTrue(order.getExecutionInfo().getPrice() == 10) self.assertTrue(order.getExecutionInfo().getCommission() == 0) self.assertTrue(len(brk.getActiveOrders()) == 0) self.assertTrue(brk.getCash() == 15+10) self.assertTrue(brk.getShares(BaseTestCase.TestInstrument) == -1) self.assertTrue(cb.eventCount == 2) # Create stop loss order. cb = Callback() brk.getOrderUpdatedEvent().subscribe(cb.onOrderUpdated) order = brk.createStopOrder(broker.Order.Action.BUY_TO_COVER, BaseTestCase.TestInstrument, 11, 1) brk.placeOrder(order) brk.onBars(self.buildBars(8, 10, 7, 9)) # Stop loss not hit. self.assertFalse(order.isFilled()) self.assertTrue(len(brk.getActiveOrders()) == 1) self.assertTrue(brk.getCash() == 15+10) self.assertTrue(brk.getShares(BaseTestCase.TestInstrument) == -1) self.assertTrue(cb.eventCount == 1) brk.onBars(self.buildBars(15, 20, 13, 14)) # Stop loss hit. self.assertTrue(order.isFilled()) self.assertTrue(order.getExecutionInfo().getPrice() == 15) self.assertTrue(len(brk.getActiveOrders()) == 0) self.assertTrue(brk.getCash() == 15-5) self.assertTrue(brk.getShares(BaseTestCase.TestInstrument) == 0) self.assertTrue(cb.eventCount == 2)
def __init__(self,
instruments,
initialCash,
fromYear,
toYear,
debugMode=True,
csvStorage="./googlefinance",
filterInvalidRows=True):
self.__logger = logger.getLogger(GoogleFinanceBacktest.LOGGER_NAME)
self.__finalPortfolioValue = 0
# Create Feed
self.__feed = googlefeed.Feed()
rowFilter = lambda row: row["Close"] == "-" or row["Open"] == "-" or row["High"] == "-" or row["Low"] == "-" or \
row["Volume"] == "-"
self.__feed = googlefinance.build_feed(
instruments,
fromYear,
toYear,
storage=csvStorage,
skipErrors=True,
rowFilter=rowFilter if filterInvalidRows else None)
# Create Broker
comissionModel = backtesting.FixedPerTrade(10)
self.__broker = backtesting.Broker(initialCash,
self.__feed,
commission=comissionModel)
self.__strategy = TradingSystem(self.__feed,
self.__broker,
debugMode=debugMode)
# Create Analyzers
returnsAnalyzer = returns.Returns()
self.__strategy.attachAnalyzer(returnsAnalyzer)
dailyResultsAnalyzer = DailyTradingResults()
self.__strategy.attachAnalyzer(dailyResultsAnalyzer)
self.__tradesAnalyzer = Trades()
self.__strategy.attachAnalyzer(self.__tradesAnalyzer)
# Create plotters
self.__plotters = []
self.__plotters.append(
plotter.StrategyPlotter(self.__strategy,
plotAllInstruments=False,
plotPortfolio=True,
plotBuySell=False))
self.__plotters[0].getOrCreateSubplot("returns").addDataSeries(
"Simple returns", returnsAnalyzer.getReturns())
self.__plotters[0].getOrCreateSubplot("dailyresult").addDataSeries(
"Daily Results", dailyResultsAnalyzer.getTradeResults())
for i in range(0, len(instruments)):
p = plotter.StrategyPlotter(self.__strategy,
plotAllInstruments=False,
plotPortfolio=False)
p.getInstrumentSubplot(instruments[i])
self.__plotters.append(p)
def __init__(self, feed, longsize, shortsize, riskfactor):
broker = backtesting.Broker(10000, feed, backtesting.FixedPerTrade(10))
super(SMAStrategyOptimizer,
self).__init__(feed=feed,
broker=broker,
tradingAlgorithm=SMATradingAlgorithm(
feed, broker, longsize, shortsize,
riskfactor),
debugMode=False)
def __init__(self, feed, entrySize, exitSize, riskFactor):
broker = backtesting.Broker(10000, feed, backtesting.FixedPerTrade(10))
super(DonchianStrategyOptimizer,
self).__init__(feed=feed,
broker=broker,
tradingAlgorithm=DonchianTradingAlgorithm(
feed, broker, entrySize, exitSize,
riskFactor),
debugMode=False)
def __init__(self, feed, fastSMA, slowSMA):
broker = backtesting.Broker({PRICE_CURRENCY: 1000}, feed)
super(SMACrossOverStrategy, self).__init__(feed, brk=broker)
ds = feed[INSTRUMENT].getPriceDataSeries()
self.__fastSMADS = ma.SMA(ds, fastSMA)
self.__slowSMADS = ma.SMA(ds, slowSMA)
self.__longPos = None
self.__shortPos = None
self.__finalValue = None
def __init__(self, barFeed, initialBalances):
brk = backtesting.Broker(initialBalances, barFeed)
super(TestStrategy, self).__init__(barFeed, brk=brk)
# Maps dates to a tuple of (method, params)
self.__orderEntry = {}
self.__brokerOrdersGTC = False
self.orderUpdatedCalls = 0
self.onStartCalled = False
self.onIdleCalled = False
self.onFinishCalled = False
def testBuyWithCommission(self): brk = backtesting.Broker(1020, barFeed=barfeed.BarFeed(barfeed.Frequency.MINUTE), commission=backtesting.FixedPerTrade(10)) # Buy order = brk.createMarketOrder(broker.Order.Action.BUY, BaseTestCase.TestInstrument, 100) brk.placeOrder(order) brk.onBars(self.buildBars(10, 15, 8, 12)) self.assertTrue(order.isFilled()) self.assertTrue(order.getExecutionInfo().getCommission() == 10) self.assertTrue(len(brk.getActiveOrders()) == 0) self.assertTrue(brk.getCash() == 10) self.assertTrue(brk.getShares(BaseTestCase.TestInstrument) == 100)
def __init__(self, feed, instruments, posMax, delay):
myBroker = broker.Broker(1000000, feed, broker.TradePercentage(0.002))
strategy.BacktestingStrategy.__init__(self, feed, myBroker)
self._delay = delay
self._liquidity = 0.05
self._positions = {}
self._posMax = posMax
self._instruments = instruments
self.setUseAdjustedValues(True)
self.getBroker().getFillStrategy().setVolumeLimit(None)
self.startDateTime = feed.peekDateTime()
self.endDateTime = None
def testReSubmit(self): brk = backtesting.Broker(1000, barFeed=barfeed.BarFeed(barfeed.Frequency.MINUTE)) cb = Callback() brk.getOrderUpdatedEvent().subscribe(cb.onOrderUpdated) order = brk.createMarketOrder(broker.Order.Action.BUY, BaseTestCase.TestInstrument, 1, False) brk.placeOrder(order) order.setFillOnClose(True) brk.placeOrder(order) # Re-submit the order after changing it. brk.onBars(self.buildBars(10, 15, 8, 12)) self.assertTrue(order.isFilled()) self.assertTrue(order.getExecutionInfo().getPrice() == 12)
def __init__(self, barFeed, cash_or_brk=1000000):
# The broker should subscribe to barFeed events before the strategy.
# This is to avoid executing orders submitted in the current tick.
if isinstance(cash_or_brk, pyalgotrade.broker.Broker):
broker = cash_or_brk
else:
broker = backtesting.Broker(cash_or_brk, barFeed)
BaseStrategy.__init__(self, barFeed, broker)
self.__useAdjustedValues = False
self.setUseEventDateTimeInLogs(True)
self.setDebugMode(True)
def __init__(self,
feed,
instrument,
bBandsPeriod,
cash=10,
comission=0.002):
broker = backtesting.Broker(cash, feed,
backtesting.TradePercentage(comission))
strategy.BaseStrategy.__init__(self, feed, broker)
self.__instrument = instrument
self.__bbands = bollinger.BollingerBands(
feed[instrument].getCloseDataSeries(), bBandsPeriod, 2)
def main():
# Replace apiToken with your own API token.
apiToken = "<YOUR API TOKEN HERE>"
# indentifiers are fully qualified identifiers for the security and must include the exchange suffix.
indentifiers = ["RIOl.CHIX", "HSBAl.CHIX"]
# apiCallDelay is necessary because the bar may not be immediately available.
apiCallDelay = 60
feed = barfeed.LiveFeed(apiToken, indentifiers, Frequency.MINUTE * 5,
apiCallDelay)
brk = backtesting.Broker(1000, feed)
myStrategy = Strategy(feed, brk)
myStrategy.run()
