backtrader_sample_es_daily.py

## backtrader_sample_es_daily.py
from __future__ import (absolute_import, division, print_function,
                        unicode_literals)
import argparse
import datetime  # For datetime objects
import os.path  # To manage paths
import sys  # To find out the script name (in argv[0])
import math

# Import the backtrader platform
import backtrader as bt
from backtrader.utils import flushfile  # win32 quick stdout flushing

import pandas as pd
import numpy as np


class SimpleMLPPredictor(bt.Indicator):
    lines = ('predict',)
    params = (('period', 10),)

    def __init__(self):
        self.addminperiod(self.params.period)

    def next(self):
        self.lines.predict[0] = get_prediction(np.random.choice([0,1]))


# Create Custom position sizer
class FixedReverser(bt.Sizer):
    params = (('stake', 1),)

    def _getsizing(self, comminfo, cash, data, isbuy):
        position = self.broker.getposition(data)
        size = self.p.stake * (1 + (position.size != 0))
        return size


#################################################
class LongShortStrategyESDaily(bt.Strategy):
    params = dict(
        smaperiod=10,
        trade=False,
        #stake=1,
        exectype=bt.Order.Market,
        stopafter=0,
        valid=None,
        cancel=0,
        donotsell=False,
    )

    def log(self, txt, dt=None):
        ''' Logging function fot this strategy'''
        dt = dt or self.datas[0].datetime.datetime(0)
        print('%s, %s' % (dt.isoformat(), txt))

    def __init__(self):
        # Keep a reference to the "close" line in the data[0] dataseries
        self.dataclose = self.datas[0].close
        self.dataopen = self.datas[0].open

        # To control operation entries
        self.orderid = list()
        self.order = None

        self.counttostop = 0
        self.datastatus = 0

        # Create SMA on 2nd data
        self.predict = SimpleMLPPredictor()

        print('--------------------------------------------------')
        print('Strategy Created')
        print('--------------------------------------------------')

    def notify_data(self, data, status, *args, **kwargs):
        print('*' * 5, datetime.datetime.now(), 'DATA NOTIF:', data._getstatusname(status), *args)
        if status == data.LIVE:
            self.counttostop = self.p.stopafter
            self.datastatus = 1

    def notify_store(self, msg, *args, **kwargs):
        print('*' * 5, datetime.datetime.now(), 'STORE NOTIF:', msg)

    def notify_order(self, order):
        if order.status in [order.Completed, order.Cancelled, order.Rejected]:
            self.order = None

        print('-' * 50, datetime.datetime.now(), 'ORDER BEGIN')
        print(order)
        print('-' * 50, datetime.datetime.now(), 'ORDER END')

    def notify_trade(self, trade):
        print('-' * 50, datetime.datetime.now(), 'TRADE BEGIN')
        print(trade)
        print('-' * 50, datetime.datetime.now(), 'TRADE END')

    def prenext(self):
        self.next(frompre=True)

    def next(self, frompre=False):
        txt = list()
        txt.append('%04d' % len(self))
        dtfmt = '%Y-%m-%dT%H:%M:%S.%f'
        txt.append('%s' % self.data.datetime.datetime(0).strftime(dtfmt))
        txt.append('{}'.format(self.data.open[0]))
        txt.append('{}'.format(self.data.high[0]))
        txt.append('{}'.format(self.data.low[0]))
        txt.append('{}'.format(self.data.close[0]))
        txt.append('{}'.format(self.data.volume[0]))
        txt.append('{}'.format(self.position.size))
        txt.append('{}'.format(self.predict[0]))
        print(', '.join(txt))

        if self.counttostop:  # stop after x live lines
            self.counttostop -= 1
            if not self.counttostop:
                self.env.runstop()
                return

        if not self.p.trade:
            return

        if self.datastatus and not self.position and len(self.orderid) < 1:
            if self.predict[0] == 1:

                # BUY, BUY, BUY!!! (with all possible default parameters)
                self.log('GO LONG, %.2f' % self.data.close[0])

                # Keep track of the created order to avoid a 2nd order
                self.order = self.buy()

            elif self.predict[0] == 0:
                # SELL, SELL, SELL!!! (with all possible default parameters)
                self.log('GO SHORT, %.2f' % self.data.close[0])

                # Keep track of the created order to avoid a 2nd order
                self.order = self.sell()

            self.orderid.append(self.order)
        elif self.datastatus and self.position.size > 0:
            if self.predict[0] == 1:
                pass

                # BUY, BUY, BUY!!! (with all possible default parameters)
                #self.log('GO LONG, %.2f' % self.dataclose[0])

                # Keep track of the created order to avoid a 2nd order
                #self.order = self.buy()

            elif self.predict[0] == 0:
                # SELL, SELL, SELL!!! (with all possible default parameters)
                self.log('REVERSE LONG TO SHORT, %.2f' % self.data.close[0])

                # Keep track of the created order to avoid a 2nd order
                self.order = self.sell()
            self.orderid.append(self.order)
        elif self.datastatus and self.position.size < 0:
            if self.predict[0] == 1:

                # BUY, BUY, BUY!!! (with all possible default parameters)
                self.log('REVERSE SHORT TO LONG, %.2f' % self.data.close[0])

                # Keep track of the created order to avoid a 2nd order
                self.order = self.buy()

            elif self.predict[0] == 0:
                pass
                # SELL, SELL, SELL!!! (with all possible default parameters)
                #self.log('GO SHORT, %.2f' % self.dataclose[0])

                # Keep track of the created order to avoid a 2nd order
                #self.order = self.sell()

        elif self.order is not None and self.p.cancel:
            if self.datastatus > self.p.cancel:
                self.cancel(self.order)

        if self.datastatus:
            self.datastatus += 1

    def start(self):
        if self.data0.contractdetails is not None:
            print('Timezone from ContractDetails: {}'.format(
                  self.data0.contractdetails.m_timeZoneId))

        header = ['Datetime', 'Open', 'High', 'Low', 'Close', 'Volume',
                  'OpenPositionSize', 'Forecast']
        print(', '.join(header))

        self.done = False


def runstrategy():

    # Create a cerebro
    cerebro = bt.Cerebro()

    storekwargs = dict(
        host='127.0.0.1', port=4003,
        clientId=103,
        timeoffset=not None,
        reconnect=3,
        timeout=3.0,
        notifyall=None,
        _debug=None
    )

    ibstore = bt.stores.IBStore(**storekwargs)
    broker = ibstore.getbroker()
    cerebro.setbroker(broker)

    timeframe = bt.TimeFrame.Days

    datatf = datatf1 = bt.TimeFrame.Ticks
    datacomp = datacomp1 = 1


    IBDataFactory = ibstore.getdata

    datakwargs = dict(
        timeframe=datatf,
        compression=datacomp,
        historical=None,
        #fromdate=None,
        fromdate=datetime.datetime(2016, 12, 1),
        #todate=datetime.datetime(2016, 12, 3),
        rtbar=None,
        qcheck=0.5,
        what=None,
        backfill_start=not None,
        backfill=not None,
        latethrough=None,
        tz=None
    )

    data0 = IBDataFactory(dataname='ES-201703-GLOBEX', **datakwargs)

    rekwargs = dict(
        timeframe=timeframe,
        compression=datacomp,
        bar2edge=not None,
        adjbartime=not None,
        rightedge=not None,
        takelate=not None,
    )

    cerebro.resampledata(dataname=data0, **rekwargs)

    cerebro.addstrategy(LongShortStrategyESDaily,
                        smaperiod=10,
                        trade=True,
                        exectype=bt.bt.Order.Market,
                        #stake=1,
                        stopafter=None,
                        valid=None,
                        cancel=0,
                        donotsell=None
                       )
    cerebro.addsizer(FixedReverser)

    # Live data ... avoid long data accumulation by switching to "exactbars"
    cerebro.run()

    #if args.plot and args.exactbars < 1:  # plot if possible
    cerebro.plot()


if __name__ == '__main__':
    runstrategy()
	from __future__ import (absolute_import, division, print_function,
	unicode_literals)
	import argparse
	import datetime # For datetime objects
	import os.path # To manage paths
	import sys # To find out the script name (in argv[0])
	import math

	# Import the backtrader platform
	import backtrader as bt
	from backtrader.utils import flushfile # win32 quick stdout flushing

	import pandas as pd
	import numpy as np


	class SimpleMLPPredictor(bt.Indicator):
	lines = ('predict',)
	params = (('period', 10),)

	def __init__(self):
	self.addminperiod(self.params.period)

	def next(self):
	self.lines.predict[0] = get_prediction(np.random.choice([0,1]))


	# Create Custom position sizer
	class FixedReverser(bt.Sizer):
	params = (('stake', 1),)

	def _getsizing(self, comminfo, cash, data, isbuy):
	position = self.broker.getposition(data)
	size = self.p.stake * (1 + (position.size != 0))
	return size




	#################################################
	class LongShortStrategyESDaily(bt.Strategy):
	params = dict(
	smaperiod=10,
	trade=False,
	#stake=1,
	exectype=bt.Order.Market,
	stopafter=0,
	valid=None,
	cancel=0,
	donotsell=False,
	)

	def log(self, txt, dt=None):
	''' Logging function fot this strategy'''
	dt = dt or self.datas[0].datetime.datetime(0)
	print('%s, %s' % (dt.isoformat(), txt))

	def __init__(self):
	# Keep a reference to the "close" line in the data[0] dataseries
	self.dataclose = self.datas[0].close
	self.dataopen = self.datas[0].open

	# To control operation entries
	self.orderid = list()
	self.order = None

	self.counttostop = 0
	self.datastatus = 0

	# Create SMA on 2nd data
	self.predict = SimpleMLPPredictor()

	print('--------------------------------------------------')
	print('Strategy Created')
	print('--------------------------------------------------')

	def notify_data(self, data, status, args, *kwargs):
	print('' 5, datetime.datetime.now(), 'DATA NOTIF:', data._getstatusname(status), *args)
	if status == data.LIVE:
	self.counttostop = self.p.stopafter
	self.datastatus = 1

	def notify_store(self, msg, args, *kwargs):
	print('' 5, datetime.datetime.now(), 'STORE NOTIF:', msg)

	def notify_order(self, order):
	if order.status in [order.Completed, order.Cancelled, order.Rejected]:
	self.order = None

	print('-' * 50, datetime.datetime.now(), 'ORDER BEGIN')
	print(order)
	print('-' * 50, datetime.datetime.now(), 'ORDER END')

	def notify_trade(self, trade):
	print('-' * 50, datetime.datetime.now(), 'TRADE BEGIN')
	print(trade)
	print('-' * 50, datetime.datetime.now(), 'TRADE END')

	def prenext(self):
	self.next(frompre=True)

	def next(self, frompre=False):
	txt = list()
	txt.append('%04d' % len(self))
	dtfmt = '%Y-%m-%dT%H:%M:%S.%f'
	txt.append('%s' % self.data.datetime.datetime(0).strftime(dtfmt))
	txt.append('{}'.format(self.data.open[0]))
	txt.append('{}'.format(self.data.high[0]))
	txt.append('{}'.format(self.data.low[0]))
	txt.append('{}'.format(self.data.close[0]))
	txt.append('{}'.format(self.data.volume[0]))
	txt.append('{}'.format(self.position.size))
	txt.append('{}'.format(self.predict[0]))
	print(', '.join(txt))

	if self.counttostop: # stop after x live lines
	self.counttostop -= 1
	if not self.counttostop:
	self.env.runstop()
	return

	if not self.p.trade:
	return

	if self.datastatus and not self.position and len(self.orderid) < 1:
	if self.predict[0] == 1:

	# BUY, BUY, BUY!!! (with all possible default parameters)
	self.log('GO LONG, %.2f' % self.data.close[0])

	# Keep track of the created order to avoid a 2nd order
	self.order = self.buy()

	elif self.predict[0] == 0:
	# SELL, SELL, SELL!!! (with all possible default parameters)
	self.log('GO SHORT, %.2f' % self.data.close[0])

	# Keep track of the created order to avoid a 2nd order
	self.order = self.sell()

	self.orderid.append(self.order)
	elif self.datastatus and self.position.size > 0:
	if self.predict[0] == 1:
	pass

	# BUY, BUY, BUY!!! (with all possible default parameters)
	#self.log('GO LONG, %.2f' % self.dataclose[0])

	# Keep track of the created order to avoid a 2nd order
	#self.order = self.buy()

	elif self.predict[0] == 0:
	# SELL, SELL, SELL!!! (with all possible default parameters)
	self.log('REVERSE LONG TO SHORT, %.2f' % self.data.close[0])

	# Keep track of the created order to avoid a 2nd order
	self.order = self.sell()
	self.orderid.append(self.order)
	elif self.datastatus and self.position.size < 0:
	if self.predict[0] == 1:

	# BUY, BUY, BUY!!! (with all possible default parameters)
	self.log('REVERSE SHORT TO LONG, %.2f' % self.data.close[0])

	# Keep track of the created order to avoid a 2nd order
	self.order = self.buy()

	elif self.predict[0] == 0:
	pass
	# SELL, SELL, SELL!!! (with all possible default parameters)
	#self.log('GO SHORT, %.2f' % self.dataclose[0])

	# Keep track of the created order to avoid a 2nd order
	#self.order = self.sell()

	elif self.order is not None and self.p.cancel:
	if self.datastatus > self.p.cancel:
	self.cancel(self.order)

	if self.datastatus:
	self.datastatus += 1

	def start(self):
	if self.data0.contractdetails is not None:
	print('Timezone from ContractDetails: {}'.format(
	self.data0.contractdetails.m_timeZoneId))

	header = ['Datetime', 'Open', 'High', 'Low', 'Close', 'Volume',
	'OpenPositionSize', 'Forecast']
	print(', '.join(header))

	self.done = False


	def runstrategy():

	# Create a cerebro
	cerebro = bt.Cerebro()

	storekwargs = dict(
	host='127.0.0.1', port=4003,
	clientId=103,
	timeoffset=not None,
	reconnect=3,
	timeout=3.0,
	notifyall=None,
	_debug=None
	)

	ibstore = bt.stores.IBStore(**storekwargs)
	broker = ibstore.getbroker()
	cerebro.setbroker(broker)

	timeframe = bt.TimeFrame.Days

	datatf = datatf1 = bt.TimeFrame.Ticks
	datacomp = datacomp1 = 1


	IBDataFactory = ibstore.getdata

	datakwargs = dict(
	timeframe=datatf,
	compression=datacomp,
	historical=None,
	#fromdate=None,
	fromdate=datetime.datetime(2016, 12, 1),
	#todate=datetime.datetime(2016, 12, 3),
	rtbar=None,
	qcheck=0.5,
	what=None,
	backfill_start=not None,
	backfill=not None,
	latethrough=None,
	tz=None
	)

	data0 = IBDataFactory(dataname='ES-201703-GLOBEX', **datakwargs)

	rekwargs = dict(
	timeframe=timeframe,
	compression=datacomp,
	bar2edge=not None,
	adjbartime=not None,
	rightedge=not None,
	takelate=not None,
	)

	cerebro.resampledata(dataname=data0, **rekwargs)

	cerebro.addstrategy(LongShortStrategyESDaily,
	smaperiod=10,
	trade=True,
	exectype=bt.bt.Order.Market,
	#stake=1,
	stopafter=None,
	valid=None,
	cancel=0,
	donotsell=None
	)
	cerebro.addsizer(FixedReverser)

	# Live data ... avoid long data accumulation by switching to "exactbars"
	cerebro.run()

	#if args.plot and args.exactbars < 1: # plot if possible
	cerebro.plot()




	if __name__ == '__main__':
	runstrategy()