nelfata
commented
4 years ago Here is the strategy I have used:
class Template(bt.Strategy):
"""A simple strategy template"""
params = {'slow' : 20,
'usebracket' : True,
'rawbracket' : False,
'pentry' : 0, # % below previous close
'plimit' : 5, # % limit price (make profit)
'pstop' : 2, # % stop price (stop loss)
'valid' : 1, #
}
def __init__(self):
self.slowma = dict()
self._addobserver(True, bt.observers.BuySell)
self.buycnt = 0
self.sellcnt = 0
self.total = 0
self.tLastOrder = time.time()
# create array of dictionary
self.o = (dict()) # orders per data (main, stop, limit, manual-close)
# fill the array index with symbols each with its own dictionary
for sym in self.getdatanames():
self.o[sym] = dict()
for sym in self.getdatanames():
# The moving averages
self.slowma[sym] = bt.indicators.SimpleMovingAverage( self.getdatabyname(sym), # The symbol for the moving average
period=self.params.slow, # Slow moving average
plotname="SlowMA: " + sym)
def log(self, txt, dt=None):
dt = dt or self.datas[0].datetime.datetime(0)
print(dt.strftime('%m-%d %H:%M:%S'), txt)
def notify_cashvalue(self, cash, value):
return
self.log('Cash %s Value %s' % (cash, value))
def notify_trade(self, trade):
sym = trade.getdataname()
#self.log(f"{sym}: SUBMITTING trade: {trade.size:.2f} {trade.price:.2f}")
if trade.isclosed:
#self.log(f"{sym}: CLOSED gross {trade.pnl:.2f} net {trade.pnlcomm:.2f}")
self.log(f"{sym}: PROFIT {trade.pnlcomm:.2f}")
def notify_order(self, order):
sym = order.data._name
ref = order.ref
date = self.datetime.date()
status = order.getstatusname()
# get the order from the
whichord = ['main', 'stop', 'limit', 'close']
dorders = self.o[sym][order.data]
idx = dorders.index(order)
self.log(f' {sym}: ref {ref} {status}: {whichord[idx]}')
# show some possible errors
if order.status in [order.Expired, order.Margin, order.Rejected]:
self.log(f' {sym}: ref {ref} {status}: {whichord[idx]}')
# NOTE:
# occasionally in live trading we receive Partial instead of Completed even though the order has been filled
if order.status in [order.Completed, order.Partial, order.Canceled, order.Expired, order.Margin, order.Rejected]:
# order canceled, remove it
#self.log(f' {sym}: ref {ref} {status}: {whichord[idx]}')
try:
dorders[idx] = None
self.log(f' {sym}: ref {ref} removed: {whichord[idx]}')
if all(x is None for x in dorders):
dorders[:] = [] # empty list - New orders allowed
self.log(f' {sym}: order list empty')
except:
print(' ERR *** order.data empty')
def next(self):
"""Define what will be done in a single step, including creating and closing trades"""
for sym in self.getdatanames(): # Looping through all symbols
d = self.getdatabyname(sym)
pos = self.getpositionbyname(sym) # pos.size, pos.price
dt = self.datetime.datetime(0)
qty = self.getsizing(d, isbuy=True)
price = d.close[0]
self.log(f'{sym}: CHECK {price:.2f} {pos.size:.2f} {pos.price:.2f} {time.time()}')
# no position, no orders
if not pos.size and not self.o[sym].get(d, None):
# Consider the possibility of entrance
# Notice the indexing; [0] always means the present bar, and [-1] the bar immediately preceding
# Thus, the condition below translates to: "If today the regime is bullish (greater than
# 0) and yesterday the regime was not bullish"
if True: #self.slowma[sym][0] > self.slowma[sym][-1]: # A buy signal
# upon startup, not all data is valid, so we wait a few seconds...
# also we need to allow time between placing orders...this is still under test
if time.time() - self.tLastOrder < 10.0:
return
self.tLastOrder = time.time()
self.log(f'{sym}: CHECK {price:.2f} {pos.size:.2f} {pos.price:.2f} {time.time()}')
if self.params.usebracket:
price = price * (1.0 - self.params.pentry / 100.0)
pstp = price * (1.0 - self.params.pstop / 100.0)
plmt = price * (1.0 + self.params.plimit / 100.0)
valid = datetime.timedelta(self.params.valid)
#pstp = 118.55
#plmt = 123.64
self.log(f'{sym}: BUY BRKT @{pstp:.2f} {price:.2f} {plmt:.2f} {valid} qty: {qty:.2f}')
if self.p.rawbracket:
o1 = self.buy (data=d, exectype=bt.Order.Limit, price=price, valid=valid, transmit=False)
o2 = self.sell(data=d, exectype=bt.Order.Stop, price=pstp, size=o1.size,transmit=False, parent=o1)
o3 = self.sell(data=d, exectype=bt.Order.Limit, price=plmt, size=o1.size,transmit=True, parent=o1)
self.o[sym][d] = [o1, o2, o3]
else:
self.o[sym][d] = self.buy_bracket( data = d,
price = price,
stopprice = pstp,
limitprice = plmt,
exectype = bt.Order.Market,
#oargs = dict(valid=valid)
)
#self.log('{}: BUY REF [Main {} Stp {} Lmt {}]'.format(sym, *(x.ref for x in self.o[sym][d])))
else:
self.o[sym][d] = [self.buy(data=d)]
self.log(f'{sym}: BUY @{price:.2f} qty: {qty:.2f}')
#self.log('{}: Buy {}'.format(sym, self.o[sym][d][0].ref))
else: # We have an open position
return
if self.slowma[sym][0] < self.slowma[sym][-1]: # A sell signal
self.log(f'{sym}: SELL *qty {self.getsizing(d, isbuy=False):.2f}')
o = self.close(data=d)
try:
self.o[sym][d].append(o) # manual order to list of orders
except:
print('Not part of order')
#return
try:
#for xo in self.o[sym][d]:
# if xo is not None:
# print('REF ',xo.ref)
#self.log('{}: CLOSE [Main {} Stp {} Lmt {}]'.format(sym, *(x.ref for x in self.o[sym][d])))
self.log('{}: Manual Close {}'.format(sym, o.ref))
except:
self.log('{sym}: No ref')
if self.p.usebracket:
try:
o = self.cancel(self.o[sym][d][1]) # cancel stop side
self.log('{}: Cancel {}'.format(sym, self.o[sym][d][1].ref))
except:
#print(self.o[sym][d])
#print('bad order sequence')
pass
shlomiku
ghost
arahmed24
After a buy order has been placed with the LIVE data feed, and was properly accepted. Monitoring the position from next() does not match what is shown on Alpaca's site. That can be easily tested by performing a buy order through the alpaca-trade-api, then closing the position on the Alpaca website. The position does not get updated in the next() function.
I am also experiencing missing notifications for bracket orders (buy limit, sell stop, sell limit). The first buy order notifications is received, but once the stop or sell limits are eventually triggered, no notifications are sent to notify_order().
This is working fine for non-live trading.