Position/Notifications not updated for bracket orders about alpaca-backtrader-api HOT 18 CLOSED

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