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()