@james-scarr
My code so far if anyone wants to play with it:
import datetime
import backtrader as bt
from pandas_datareader import data as pdr
Get stock data from yahoo
def get_data(stock, start, end):
stockData = pdr.get_data_yahoo(stock, start, end)
return stockData
Use the S&P500 Symbol ^GSPC on Yahoo Finance
stock = '^GSPC'
Choose stock data to retrieve and set a start and end date
endDate = datetime.datetime(2021,1,1)
startDate = datetime.datetime(2020,1,1)
stockData = get_data(stock, startDate, endDate)
Actual start date is the start of the following day
actualStart = stockData.index[0]
Put data in a format that BackTrader understands
data = bt.feeds.PandasData(dataname=stockData)
######################
class CommInfoFractional(bt.CommissionInfo):
def getsize(self, price, cash):
'''Returns fractional size for cash operation @price'''
return self.p.leverage * (cash / price)
######################
class FixedCommisionScheme(bt.CommInfoBase):
paras = (
('commission', 10),
('stocklike', True),
('commtype', bt.CommInfoBase.COMM_FIXED)
)
def _getcommission(self, size, price, pseudoexec):
return self.p.commission
#####################
class PoundCostAveraging(bt.Strategy):
params = dict(
monthly_cash=500,
monthly_range=[1]
)
def __init__(self):
# Keep track of variables
self.order = None
self.totalcost = 0
self.cost_wo_bro = 0
self.units = 0
self.times = 0
def log(self, txt, dt=None):
# Print the trades as they occur
dt = dt or self.datas[0].datetime.date(0)
print(dt.isoformat() + ', ' + txt)
def start(self):
self.broker.set_fundmode(fundmode=True, fundstartval=100.0)
self.cash_start = self.broker.get_cash()
self.val_start = 100.0
# ADD A TIMER
self.add_timer(
when=bt.timer.SESSION_START,
monthdays=[i for i in self.p.monthly_range],
monthcarry=True
# timername='buytimer',
)
def notify_timer(self, timer, when, *args):
self.broker.add_cash(self.p.monthly_cash)
target_value = self.broker.get_value() + self.p.monthly_cash - 10
self.order_target_value(target=target_value)
def notify_order(self, order):
if order.status in [order.Submitted, order.Accepted]:
return
if order.status in [order.Completed]:
if order.isbuy():
self.log(
'BUY EXECUTED, Price %.2f, Cost %.2f, Comm %.2f, Size %.0f' %
(order.executed.price,
order.executed.value,
order.executed.comm,
order.executed.size)
)
self.units += order.executed.size
self.totalcost += order.executed.value + order.executed.comm
self.cost_wo_bro += order.executed.value
self.times += 1
elif order.status in [order.Canceled, order.Margin, order.Rejected]:
self.log('Order Canceled/Margin/Rejected')
print(order.status, [order.Canceled, order.Margin, order.Rejected])
self.order = None
def stop(self):
# calculate actual returns
self.roi = (self.broker.get_value() / self.cash_start) - 1
self.froi = (self.broker.get_fundvalue() - self.val_start)
value = self.datas[0].close * self.units + self.broker.get_cash()
print('-'*50)
print('PoundCostAveraging')
print('For year ending in ' + str(endDate))
print('Time in Market: {:.1f} years'.format((endDate - actualStart).days/365))
print('#Times: {:.0f}'.format(self.times))
print('Value: ${:,.2f}'.format(value))
print('Cost: ${:,.2f}'.format(self.totalcost))
print('Gross Return: ${:,.2f}'.format(value - self.totalcost))
print('Gross %: {:.2f}%'.format((value/self.totalcost - 1) * 100))
print('ROI: {:.2f}%'.format(100.0 * self.roi))
print('Fund Value: {:.2f}%'.format(self.froi))
print('Annualised: {:.2f}%'.format(100*((1+self.froi/100)**(365/(endDate - actualStart).days) - 1)))
print('-'*50)
########################
def run(data):
# Pound Cost Averaging
cerebro = bt.Cerebro()
cerebro.adddata(data)
cerebro.addstrategy(PoundCostAveraging)
# Broker Information
broker_args = dict(coc=True)
cerebro.broker = bt.brokers.BackBroker(**broker_args)
cerebro.broker.addcommissioninfo(CommInfoFractional())
#comminfo = FixedCommisionScheme()
#cerebro.broker.addcommissioninfo(comminfo)
cerebro.broker.set_cash(500)
cerebro.run()
cerebro.plot(iplot=False, style='candlestick')
if name == 'main':
run(data)
