BT has built in 'Highest' and 'Lowest' indicators that will do this for you.

https://www.backtrader.com/docu/indautoref/#highest
https://www.backtrader.com/docu/indautoref/#lowest

For a long time I used it wrong a received inconsistent results. This structure works for me now:

import backtrader as bt
import backtrader.indicators as bt.ind

class TheStrategy(bt.Strategy):

    params = (
        ('highperiod_0', 60),
        ('lowperiod_0', 60),
        )

def __init__(self):

    self.highest = highest = bt.ind.Highest(self.data, period=self.p.highperiod_0, plot=True, subplot=False)
    self.lowest = lowest = bt.ind.Lowest(self.data, period=self.p.lowperiod_0, plot=True, subplot=False)


def next(self):

    #LONG POSITION: Breakout high when
    self.data.close > self.highest
    self.buy()
    
    #SHORT POSITION: Breakout low when
    self.data.close() < self.lowest
    self.sell

You need to set the period for the number of bars you want to find the highest/lowest data for. Once you have this static high/low working, try using a dynamic indicator for something a little more complex:

https://www.backtrader.com/blog/posts/2018-02-06-dynamic-indicator/dynamic-indicator/

@ab_trader Thanks for the info.

Working indicator with two conditions (open and close > bb.mid).

import backtrader as bt
import backtrader.indicators as btind


class AboveBBmid(bt.Indicator):

    lines = ('open', 'close')
    params = (
        ('period', 15),  # how many to consider
        ('ago', 0),  # offset to start in the past
        ('bbperiod', 20),  # offset to start in the past
        ('devfactor', 2),  # offset to start in the past
    )

    def __init__(self):
        
        self.bollband = bt.indicators.BollingerBands(self.data, period=self.p.bbperiod, devfactor=self.p.devfactor, plot=False)
        
        bar_open = [self.data.open(-i) > self.bollband.lines.mid(-i) for i in range(self.p.ago, self.p.ago + self.p.period)]
        
        self.lines.open = bt.All(*bar_open)

        bar_close = [self.data.close(-i) > self.bollband.lines.mid(-i) for i in range(self.p.ago, self.p.ago + self.p.period)]
        
        self.lines.close = bt.All(*bar_close)
        
        self.combined = bt.And(self.lines.open, self.lines.close)

Ok - so I've worked up a solution.

Let's assume you want to enter or exit (dynamic take profit or stop loss) faster than the next bar of your primary timeframe that drives your indicators. In this example I have my main indicators on data1 with timeframe = 1 min. I also have data0 set to 5 sec.

Adapting the line coupler examples from here to Bollinger Bands, instead of Pivot Points and SMAs:
https://www.backtrader.com/docu/concepts/#lines-coupling
and here:
https://www.backtrader.com/blog/posts/2016-05-05-indicators-mixing-timeframes/indicators-mixing-timeframes/

In this scenario, instead of waiting 1min to complete the bar to enter a position, if 5 second bars from self.data0.low or self.data0.high breach the Bollinger bands defined using 1min, then orders will be placed.

This provided a much faster response to shifting prices that sometimes triggered an entry but then moved away from the 'optimal' trade point before the 1 min bar was complete.

From my testing, be sure to only reference the coupled Bollinger references. If referring to self.boll (pre-couple), errors will occur. That had me stumped for a while when using legacy code that wasn't referencing the bb line coupling.

class TheStrategy(bt.Strategy):

    params = (
        bbperiod = 20
        devfactor = 2
        )

    def __init__(self):

        self.boll = bb_lc = bt.indicators.BollingerBands(self.data1, period=self.p.bbperiod, devfactor=self.p.devfactor, plot=False) #Standard, uncoupled Bollinger Band indicator.

        #BELOW: LINE COUPLED BOLLINGER BANDS AND DATA0

        bb_lc1 = bb_lc()    #Couple the Boll Band indicators
        self.bb_lc1_range = bb_lc1.top - bb_lc1.bot     #Range between BB top and bottom lines
        
        self.bb_lc1_top = bb_lc1.top    #Reference for formulas later in next() [not shown]
        self.bb_lc1_bot = bb_lc1.bot    #Reference for formulas later in next() [not shown]
        
        self.buysig = (self.data0.low < bb_lc1.bot) #BUY when data0 (5 secs) falls below BB Bottom on data1 lines (1min)
        self.sellsig = (self.data0.high > bb_lc1.top)   #SELL when data0 (5 secs) moves above BB Top on data1 lines (1min)

    def next(self):

        if not self.position:
            if  (self.buysig[0]):
                #BUY ORDER
            if (self.sellsig[0]):
                #SELL ORDER
            

TURNING OFF PLOTTING 'LINESCOUPLER'

Once you have lines coupled, but you do not want to show the lines when plotting, turn them off using this:

#data0 = lower timeframe
#data1 = higher timeframe


def __init__():
     #data1 Bollinger Bands
     self.boll = bb_lc = bt.indicators.BollingerBands(self.data1, period=self.p.bbperiod, devfactor=self.p.devfactor, plot=True)

     #Line Coupling used on Bollinger Bands
     bb_lc1 = bb_lc()

     #Turn off plotting of LinesCoupler
     bb_lc1.plotinfo.plot = False

More options on plotting:
https://www.backtrader.com/docu/plotting/plotting/

Sharing a simple candle indicator. These two patterns (coupled with other price movements), can be good indicators for price reversal:

• 3 White Soldiers
• 3 Black Crows

This is an adaptation from an earlier post by @backtrader.

3 Black Crows Example:

import backtrader as bt

class BlackCrows(bt.Indicator):

    lines = ('crows',)
    params = (
        ('period', 3),  # how many to consider
        ('ago', 0),  # offset to start in the past
    )

    def __init__(self):
        incs = [self.data.close(-i) < self.data.open(-i) for i in range(self.p.ago, self.p.ago + self.p.period)]
        self.lines.crows = bt.All(*incs)

Use in strategy below. I often use 5 consecutive candles when there has been a fast move that is reversing.

class TheStrategy(bt.Strategy):
    
    def __init__(self):
        self.three_crows = BlackCrows(self.data)  # 3 black crows. Default period = 3
        self.five_crows = BlackCrows(self.data, period=5)  # 5 black crows. Overrides period = 5

I have a comparable trading scenario where position gets 'flipped', rather than closing and then opening a new order. As long as your broker/account is set up for 'account netting' this will work.

The scenario below is when there is an open short position, then a scenario is hit where I want to flip the position to long, cancel stop loss from the old short position and set a new stop loss for the new long position.

#IN SHORT POSITION THEN TRIGGER FOR FLIP OCCURS#

posi = abs(self.position.size)  #Get open position size
stake_flip = (2 * posi)  #Double the open position size for flipping

buy_ord = self.buy(exectype=bt.Order.Market, size=stake_flip)  #Reverse short position by buying 2 x position
buy_ord.addinfo(name='Long_' + self.productname + self.stratname)  #Add info to order

cancel = self.cancel(self.stop_ord_buy)  #Cancel old short position stop loss

self.stop_ord_sell = self.sell(exectype=bt.Order.Stop, price=self.long_stop, size=posi)  #Create new stop loss for long position
self.stop_ord_sell.addinfo(name=self.productname+'LongStopLoss') #Add info to order

This approach allows for only one order to be processed instead of two (closing and opening new) in the same bar.

@Alexandre-Durand

I have a system that provides some functionality that you are after by storing all critical variables, trade data, account data in an *.ini file which is updated on each loop of next(). While this is not exactly what you might be after, it may overcome your problem until a better solution can be found.

How my system works on initial start:

• Parent program
  • Creates *.ini file
  • Runs BT as subprocess
  • BT starts normally

When connection fails

• notify_store receives error
• wait for connection to be restored (but BT does not resume)
  • send sms alerting me of restart
  • try send close position and try cancel stop loss (if any are open). API still receives these commands even when BT cannot resume.
  • runstop BT
• write variable to ini file signalling shutdown (this is for the parent program to read and action)

When shutdown recognised by parent program

• kill BT
  -reload BT

When BT reloads

• check if fresh start or reload.
  • If reload, then init with variables from last loop of next() prior to shutdown
  • If fresh start, init with normal defaults
  • [Option here to recreate the positions that had to been closed when BT failed so that the strategy can continue depending on how much time and price has moved]

Here is some sample code:

NOTIFY_STORE

def notify_store(self, msg, *args, **kwargs):

    print('*' * 5, 'STORE NOTIF:', msg)
    
    try:
        if 'external transaction MARKET_ORDER' in msg:
            print('msg = external transaction')
            
            self.hitstoploss = 0
            
            try:
                cancel = self.cancel(self.stop_ord) #CANCEL STOP LOSS
                print('CANCEL STOP LOSS')
                return
                
            except AttributeError:
                print('NO STOP LOSS TO CANCEL')
                return
                
            else:
            
                print('NOT SURE IF STOP LOSS CURRENTLY OPEN')
                try:
                    message = SendSMS.client.messages.create(
                        from_='+xxxxxxxxxx',
                        to='+xxxxxxxxxx',
                        body=(self.productcode + ' FAILED TO CANCEL STOP LOSS: CHECK ON PLATFORM'))
                except:
                    pass
                return

    except:
            
        print('CONNECTION FAILED')
        
        print('SEND SMS')
                    
        x = 1
        while True: #IF INTERNET CONNECTION DOWN. WAIT UNTIL ABLE TO SEND SMS BEFORE COMMENCING RELOAD
            try:
                
                message = SendSMS.client.messages.create(
                    from_='+xxxxxxxxxx',
                    to='+xxxxxxxxxx',
                    body=('SHUT DOWN: CLOSING POSITIONS & RELOADING'))
#                        body=(self.productcode + ' SHUT DOWN: CLOSING POSITIONS & RELOADING: {}'.format(msg)))

                print('SMS SENT')
                break
            except:
                print('!!! CONNECTION BROKEN !!! - FAILED TO SEND SMS. RETRYING #' + str(x))
                time.sleep(2)
                x = x + 1
                pass
        
        print('GET POSITION SIZE FROM INI FILE')
        #READ INI TO GET POSTION SIZE. CANNOT GET POSITION SIZE FROM BROKER IF CONNECTION INTERUPTED
        bt_file.read_trade_ini(self)
        time.sleep(2)
        print('INI FILE READ')
        print('POSITION SIZE: ' + str(self.position_size)) #self.position_size IS READ FROM THE INI FILE AND GETS UPDATED ON EACH next()
       
        print('TRY TO CLOSE POSITION')
        time.sleep(10)
        try:
           self.close(size=self.position_size) #SEND A CLOSE ORDER. THIS WILL WORK IF API CONNECTION RE-ESTABLISHED, EVEN IF BT HAS STALLED
        except:
            pass
#            time.sleep(2)
        print('POSITION CLOSED. TRY TO CANCEL STOP LOSS')
        try:
            self.cancel(self.stop_ord) #SEND A CANCEL STOP LOSS ORDER. THIS WILL WORK IF API CONNECTION RE-ESTABLISHED, EVEN IF BT HAS STALLED
        except:
            pass
        print('CANCEL STOP LOSS')

        time.sleep(2)
        bt_file.reload_write(self)    #CREATE SHUTDOWN TRIGGER IN INI FILE FOR PARENT PROGRAM TO RECEIVE
        time.sleep(2)
        print('STOPPING BACKTRADER')
        self.env.runstop()  #SHUT DOWN BACKTRADER
        time.sleep(1)
        press('enter')  #MUST KEEP CURSOR ACTIVE ON THE TERMINAL FOR THIS TO WORK
        return

PARENT PROGRAM

***FRESH START***

    #----- ESTABLISH INI FILE -----#

    config = configparser.ConfigParser()
    home = os.path.expanduser('~') #USER DIRECTORY
    filename = pc + '.ini'
    
    if not os.path.exists(home + '/00_config/' + filename):
        print('CREATING NEW INI FILE')
        f = open(home + '/00_config/' + filename, 'w')
    else:
        print('EXISTING INI FILE')
        pass
    
    myfile = Path(home + '/00_config/' + filename)
    
    config.read(myfile)
    section_00 = pc
    section_01 = pc + '-01'
    section_02 = pc + '-02'
    
    time.sleep(1)
    
    #----- CLEAR INI FILE -----#
    print('PREPARING INI FILE')
    with open(myfile,'r+') as s:
        config.read_file(s)
        config.remove_section(section_00)
        config.remove_section(section_01)
        config.remove_section(section_02)
        s.seek(0)
        config.write(s)
        s.truncate()
        
    time.sleep(1)
    #----- CREATE RELOAD SECTIONS IF THEY DO NOT EXIST -----#
    try:
        config.get(section_01, 'override')
    except:
#    except configparser.NoSectionError:
        config.add_section(section_01)   #ADD NEW SECTION
    
    #CREATE ACCOUNT SECTION IF IT DOES NOT EXIST
    try:
        config.get(section_02, 'account')
    except:
#    except configparser.NoSectionError:
        config.add_section(section_02)
        
    #CREATE TRADE DATA SECTION IF IT DOES NOT EXIST
    try:
        config.get(pc, 'tradeid')
    except:
#    except configparser.NoSectionError:
        config.add_section(pc)
    
    #----- RELOAD DEFAULT VALUES -----#
    config.set(section_01, 'override','0')
    config.set(section_01, 'reload','0')
    config.set(section_02, 'account','0')
    config.write(myfile.open('w'))

  
    #----- LOAD CEREBRO -----#
    cerebro(pc) #LOADS BT ('pc' refers to product code that is passed to BT from the parent)

***LOOP CHECKS ON INI FILE***

    while True:

#----- CONNECTION FAILURE - RELOAD -----#

        config.read(myfile)
        reload_sc = config.get(section_01,'reload')

        if reload_sc == 'SHUTDOWN': #IF INI FILE SAYS 'SHUTDOWN' (WHICH IS SET BY NOTIFY_STORE), THEN...
        
            print('KILL CEREBRO')
            #use to have a kill.subprocess command in here but it seemed redundant but might be useful if running multiple instances on one machine
            time.sleep(1)
            print('RELOAD CEREBRO')
            time.sleep(2)
            cerebro(pc)

        else:
            pass

BT

***FRESH START***

def __init__():

        ini_transfer.reload_read(self) #Loads ini file

        if self.reload_sc == 'SHUTDOWN': #If reloaded set as'SHUTDOWN' then init with last values, not default
            ini_transfer.read_restart_data(self) 
        else:
            vars(self) #This is just a method contain a group of variables

SAMPLE CODE FROM INI_TRANSFER

    def read_restart_data(self):
        args = parse_args()
        config = configparser.ConfigParser()
        home = os.path.expanduser('~')
        myfile = Path(home + '/00_config/' + args.data0 + '.ini')
        config.read(myfile) #path of your .ini file
        
        self.tradeid = config.get(args.data0,'tradeid')
        self.position_size = float(config.get(args.data0,'position_size'))
        self.freezebar = float(config.get(args.data0,'freezebar'))
        self.enter_price = float(config.get(args.data0,'enter_price'))
        self.retracement = float(config.get(args.data0,'retracement'))
        self.hitstoploss = int(config.get(args.data0,'hitstoploss'))
        self.high_2 = float(config.get(args.data0,'high_2'))
        self.low_2 = float(config.get(args.data0,'low_2'))
        self.high_3 = float(config.get(args.data0,'high_3'))
        self.pos_long = int(config.get(args.data0,'pos_long'))
        self.pos_short = int(config.get(args.data0,'pos_short'))
        self.stop_position = float(config.get(args.data0,'stop_position'))
        self.trend_backflip = float(config.get(args.data0,'trend_backflip'))
        self.trend_exit_trigger = float(config.get(args.data0,'trend_exit_trigger'))
        self.false_signal = float(config.get(args.data0,'false_signal'))
        self.RTH = int(config.get(args.data0,'RTH'))
        self.trend_exit_price = float(config.get(args.data0,'trend_exit_price'))
        self.break_out_long = float(config.get(args.data0,'break_out_long'))
        self.break_out_short = float(config.get(args.data0,'break_out_short'))

Perhaps some of this might assist you with new ideas to tackle your problem.

Also appreciate if anyone has ideas on how to improve or simplify this?

Not being from a coding background, I am making this up as I go. No doubt there are more efficient ways of achieving some of the things I am doing.

Has anyone had success in creating real-time plotting. Cerebro does not appear to be the solution here, however, it appears others have found a way that might leave clues on how to accomplish this.

A programmer (sendex) has previously created live stock plotting, however, this is back in the day when Yahoo finance was available. Here is his post:
https://pythonprogramming.net/advanced-matplotlib-graphing-charting-tutorial/

Does anyone have the skills to alter this code so that it draws data from stores like Interactive Brokers or OANDA, while still being able to leverage Backtrader for analysis?

FYI - I would replace the def rsiFunc, def movingaverage, def ExpMovingAverage and def computeMACD with the Backtrader, but before commencing this it would be good to know how to leverage IB or OANDA as the data source.

Can anyone help?

As far as I can tell the following section needs editing...

def graphData(stock,MA1,MA2):

        #Use this to dynamically pull a stock:

    try:
        print('Currently Pulling',stock)
        urlToVisit = 'http://chartapi.finance.yahoo.com/instrument/1.0/'+stock+'/chartdata;type=quote;range=10y/csv'
        stockFile =[]
        try:
            sourceCode = urllib.request.urlopen(urlToVisit).read().decode()
            splitSource = sourceCode.split('\n')
            for eachLine in splitSource:
                splitLine = eachLine.split(',')
                if len(splitLine)==6:
                    if 'values' not in eachLine:
                        stockFile.append(eachLine)
        except Exception as e:
            print(str(e), 'failed to organize pulled data.')
    except Exception as e:
        print(str(e), 'failed to pull pricing data')

    try:
        date, closep, highp, lowp, openp, volume = np.loadtxt(stockFile,delimiter=',', unpack=True,
                                                              converters={ 0: bytespdate2num('%Y%m%d')})
    

FULL CODE (BY SENDEX) HERE:

# THIS VERSION IS FOR PYTHON 3 #
import urllib.request, urllib.error, urllib.parse
import time
import datetime
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.ticker as mticker
import matplotlib.dates as mdates
from matplotlib.finance import candlestick_ohlc
import matplotlib
import pylab
matplotlib.rcParams.update({'font.size': 9})

def rsiFunc(prices, n=14):
    deltas = np.diff(prices)
    seed = deltas[:n+1]
    up = seed[seed>=0].sum()/n
    down = -seed[seed<0].sum()/n
    rs = up/down
    rsi = np.zeros_like(prices)
    rsi[:n] = 100. - 100./(1.+rs)

    for i in range(n, len(prices)):
        delta = deltas[i-1] # cause the diff is 1 shorter

        if delta>0:
            upval = delta
            downval = 0.
        else:
            upval = 0.
            downval = -delta

        up = (up*(n-1) + upval)/n
        down = (down*(n-1) + downval)/n

        rs = up/down
        rsi[i] = 100. - 100./(1.+rs)

    return rsi

def movingaverage(values,window):
    weigths = np.repeat(1.0, window)/window
    smas = np.convolve(values, weigths, 'valid')
    return smas # as a numpy array


def ExpMovingAverage(values, window):
    weights = np.exp(np.linspace(-1., 0., window))
    weights /= weights.sum()
    a =  np.convolve(values, weights, mode='full')[:len(values)]
    a[:window] = a[window]
    return a


def computeMACD(x, slow=26, fast=12):
    """
    compute the MACD (Moving Average Convergence/Divergence) using a fast and slow exponential moving avg'
    return value is emaslow, emafast, macd which are len(x) arrays
    """
    emaslow = ExpMovingAverage(x, slow)
    emafast = ExpMovingAverage(x, fast)
    return emaslow, emafast, emafast - emaslow


def bytespdate2num(fmt, encoding='utf-8'):
    strconverter = mdates.strpdate2num(fmt)
    def bytesconverter(b):
        s = b.decode(encoding)
        return strconverter(s)
    return bytesconverter

def graphData(stock,MA1,MA2):

    '''
        Use this to dynamically pull a stock:
    '''
    try:
        print('Currently Pulling',stock)
        urlToVisit = 'http://chartapi.finance.yahoo.com/instrument/1.0/'+stock+'/chartdata;type=quote;range=10y/csv'
        stockFile =[]
        try:
            sourceCode = urllib.request.urlopen(urlToVisit).read().decode()
            splitSource = sourceCode.split('\n')
            for eachLine in splitSource:
                splitLine = eachLine.split(',')
                if len(splitLine)==6:
                    if 'values' not in eachLine:
                        stockFile.append(eachLine)
        except Exception as e:
            print(str(e), 'failed to organize pulled data.')
    except Exception as e:
        print(str(e), 'failed to pull pricing data')

    try:
        date, closep, highp, lowp, openp, volume = np.loadtxt(stockFile,delimiter=',', unpack=True,
                                                              converters={ 0: bytespdate2num('%Y%m%d')})
        x = 0
        y = len(date)
        newAr = []
        while x < y:
            appendLine = date[x],openp[x],highp[x],lowp[x],closep[x],volume[x]
            newAr.append(appendLine)
            x+=1
            
        Av1 = movingaverage(closep, MA1)
        Av2 = movingaverage(closep, MA2)

        SP = len(date[MA2-1:])
            
        fig = plt.figure(facecolor='#07000d')

        ax1 = plt.subplot2grid((6,4), (1,0), rowspan=4, colspan=4, axisbg='#07000d')
        candlestick_ohlc(ax1, newAr[-SP:], width=.6, colorup='#53c156', colordown='#ff1717')

        Label1 = str(MA1)+' SMA'
        Label2 = str(MA2)+' SMA'

        ax1.plot(date[-SP:],Av1[-SP:],'#e1edf9',label=Label1, linewidth=1.5)
        ax1.plot(date[-SP:],Av2[-SP:],'#4ee6fd',label=Label2, linewidth=1.5)
        
        ax1.grid(True, color='w')
        ax1.xaxis.set_major_locator(mticker.MaxNLocator(10))
        ax1.xaxis.set_major_formatter(mdates.DateFormatter('%Y-%m-%d'))
        ax1.yaxis.label.set_color("w")
        ax1.spines['bottom'].set_color("#5998ff")
        ax1.spines['top'].set_color("#5998ff")
        ax1.spines['left'].set_color("#5998ff")
        ax1.spines['right'].set_color("#5998ff")
        ax1.tick_params(axis='y', colors='w')
        plt.gca().yaxis.set_major_locator(mticker.MaxNLocator(prune='upper'))
        ax1.tick_params(axis='x', colors='w')
        plt.ylabel('Stock price and Volume')

        maLeg = plt.legend(loc=9, ncol=2, prop={'size':7},
                   fancybox=True, borderaxespad=0.)
        maLeg.get_frame().set_alpha(0.4)
        textEd = pylab.gca().get_legend().get_texts()
        pylab.setp(textEd[0:5], color = 'w')

        volumeMin = 0
        
        ax0 = plt.subplot2grid((6,4), (0,0), sharex=ax1, rowspan=1, colspan=4, axisbg='#07000d')
        rsi = rsiFunc(closep)
        rsiCol = '#c1f9f7'
        posCol = '#386d13'
        negCol = '#8f2020'
        
        ax0.plot(date[-SP:], rsi[-SP:], rsiCol, linewidth=1.5)
        ax0.axhline(70, color=negCol)
        ax0.axhline(30, color=posCol)
        ax0.fill_between(date[-SP:], rsi[-SP:], 70, where=(rsi[-SP:]>=70), facecolor=negCol, edgecolor=negCol, alpha=0.5)
        ax0.fill_between(date[-SP:], rsi[-SP:], 30, where=(rsi[-SP:]<=30), facecolor=posCol, edgecolor=posCol, alpha=0.5)
        ax0.set_yticks([30,70])
        ax0.yaxis.label.set_color("w")
        ax0.spines['bottom'].set_color("#5998ff")
        ax0.spines['top'].set_color("#5998ff")
        ax0.spines['left'].set_color("#5998ff")
        ax0.spines['right'].set_color("#5998ff")
        ax0.tick_params(axis='y', colors='w')
        ax0.tick_params(axis='x', colors='w')
        plt.ylabel('RSI')

        ax1v = ax1.twinx()
        ax1v.fill_between(date[-SP:],volumeMin, volume[-SP:], facecolor='#00ffe8', alpha=.4)
        ax1v.axes.yaxis.set_ticklabels([])
        ax1v.grid(False)
        ###Edit this to 3, so it's a bit larger
        ax1v.set_ylim(0, 3*volume.max())
        ax1v.spines['bottom'].set_color("#5998ff")
        ax1v.spines['top'].set_color("#5998ff")
        ax1v.spines['left'].set_color("#5998ff")
        ax1v.spines['right'].set_color("#5998ff")
        ax1v.tick_params(axis='x', colors='w')
        ax1v.tick_params(axis='y', colors='w')
        ax2 = plt.subplot2grid((6,4), (5,0), sharex=ax1, rowspan=1, colspan=4, axisbg='#07000d')
        fillcolor = '#00ffe8'
        nslow = 26
        nfast = 12
        nema = 9
        emaslow, emafast, macd = computeMACD(closep)
        ema9 = ExpMovingAverage(macd, nema)
        ax2.plot(date[-SP:], macd[-SP:], color='#4ee6fd', lw=2)
        ax2.plot(date[-SP:], ema9[-SP:], color='#e1edf9', lw=1)
        ax2.fill_between(date[-SP:], macd[-SP:]-ema9[-SP:], 0, alpha=0.5, facecolor=fillcolor, edgecolor=fillcolor)

        plt.gca().yaxis.set_major_locator(mticker.MaxNLocator(prune='upper'))
        ax2.spines['bottom'].set_color("#5998ff")
        ax2.spines['top'].set_color("#5998ff")
        ax2.spines['left'].set_color("#5998ff")
        ax2.spines['right'].set_color("#5998ff")
        ax2.tick_params(axis='x', colors='w')
        ax2.tick_params(axis='y', colors='w')
        plt.ylabel('MACD', color='w')
        ax2.yaxis.set_major_locator(mticker.MaxNLocator(nbins=5, prune='upper'))
        for label in ax2.xaxis.get_ticklabels():
            label.set_rotation(45)

        plt.suptitle(stock.upper(),color='w')
        plt.setp(ax0.get_xticklabels(), visible=False)
        plt.setp(ax1.get_xticklabels(), visible=False)
        
        ax1.annotate('Big news!',(date[510],Av1[510]),
            xytext=(0.8, 0.9), textcoords='axes fraction',
            arrowprops=dict(facecolor='white', shrink=0.05),
            fontsize=14, color = 'w',
            horizontalalignment='right', verticalalignment='bottom')

        plt.subplots_adjust(left=.09, bottom=.14, right=.94, top=.95, wspace=.20, hspace=0)
        plt.show()
        fig.savefig('example.png',facecolor=fig.get_facecolor())
           
    except Exception as e:
        print('main loop',str(e))

while True:
    stock = input('Stock to plot: ')
    graphData(stock,10,50)

@Nikolai - Great work on this! Did the issue with self.position get resolved?

My strategy is running as it should but when an order is place, it is being received and accepted but self.position remains at 0. This is causing multiple repeated orders to be opened.

SOLVED

Turns out that OANDA needs to received the value as a string. The following changes to oandav20store.py now allow for fractional order sizes.

Warning... make sure what ever sizer calculation you are using doesn't leave minor decimal positions open. Build your own sizer model!

    def order_create(self, order, stopside=None, takeside=None, **kwargs):
        '''Creates an order'''
        okwargs = dict()
        okwargs['instrument'] = order.data._dataname
        okwargs['units'] = (
            #ORIGINAL CODE
             #abs(int(order.created.size)) if order.isbuy()
             #else -abs(int(order.created.size)))  # negative for selling

            #NEW CODE: WORKS WITH FRACTIONAL ORDER SIZES
            str(abs(order.created.size)) if order.isbuy()
            else str(-abs(order.created.size)))  # negative for selling

I am trying to alter the oandav20store.py file to allow for fractional position sizes. The following function (in its original format) altered all create order sizes to be integers.

When I delete the 'int' from the code and try to place an order with self.stake=1.4 it shows on OANDA activity as 'MARKET ORDER REJECT' with unit size 1.4.

To test this with a hardcoded figure, if I replace the 'order.created.size' with '1.6' (just to be different), then the order is placed correctly and accepted by OANDA at 1.6 Units with a Stop at 1.6 Units.

Anyone have idea on how to get order.created.size to work without being an integrer and equal the size of the buy order so that I can use self.stake as a dynamic variable?

#PLACE ORDER
self.stake = 1.4
self.buy(exectype=bt.Order.Market, size=self.stake)
self.sell(exectype=bt.Order.Stop, price=self.stop_loss, size=self.stake)

From oandav20store.py:

    def order_create(self, order, stopside=None, takeside=None, **kwargs):
        '''Creates an order'''
        okwargs = dict()
        okwargs['instrument'] = order.data._dataname
        okwargs['units'] = (
            #ORIGINAL CODE
            #abs(int(order.created.size)) if order.isbuy()
            #else -abs(int(order.created.size)))  # negative for selling

            #DOES NOT WORK WITH 'int' REMOVED
            abs(order.created.size) if order.isbuy()
            else -abs(order.created.size))  # negative for selling
            
            #DOES WORK IF A FIXED DECIMAL VALUE IS USED FOR TESTING
            #abs(1.6) if order.isbuy()
            #else -abs(1.6))  # negative for selling

        okwargs['type'] = self._ORDEREXECS[order.exectype]

        if order.exectype != bt.Order.Market:
            okwargs['price'] = format(
                order.created.price,
                '.%df' % order.data.contractdetails['displayPrecision'])
            if order.valid is None:
                okwargs['timeInForce'] = 'GTC'  # good to cancel
            else:
                okwargs['timeInForce'] = 'GTD'  # good to date
                gtdtime = order.data.num2date(order.valid)
                okwargs['gtdTime'] = gtdtime.strftime(self._DATE_FORMAT)

        if order.exectype == bt.Order.StopLimit:
            okwargs['priceBound'] = order.created.pricelimit

        if order.exectype == bt.Order.StopTrail:
            okwargs['distance'] = format(
                order.trailamount,
                '.%df' % order.data.contractdetails['displayPrecision'])

        if stopside is not None:
            if stopside.exectype == bt.Order.StopTrail:
                okwargs['trailingStopLossOnFill'] = v20.transaction.TrailingStopLossDetails(
                    distance=format(
                        stopside.trailamount,
                        '.%df' % order.data.contractdetails['displayPrecision']),
                    clientExtensions=v20.transaction.ClientExtensions(
                        id=str(stopside.ref)
                    ).dict()
                ).dict()
            else:
                okwargs['stopLossOnFill'] = v20.transaction.StopLossDetails(
                    price=format(
                        stopside.price,
                        '.%df' % order.data.contractdetails['displayPrecision']),
                    clientExtensions=v20.transaction.ClientExtensions(
                        id=str(stopside.ref)
                    ).dict()
                ).dict()

        if takeside is not None and takeside.price is not None:
            okwargs['takeProfitOnFill'] = v20.transaction.TakeProfitDetails(
                price=format(
                    takeside.price,
                    '.%df' % order.data.contractdetails['displayPrecision']),
                clientExtensions=v20.transaction.ClientExtensions(
                    id=str(takeside.ref)
                ).dict()
            ).dict()

        # store backtrader order ref in client extensions
        okwargs['clientExtensions'] = v20.transaction.ClientExtensions(
            id=str(order.ref)
        ).dict()

        okwargs.update(**kwargs)  # anything from the user
        self.q_ordercreate.put((order.ref, okwargs,))

        # notify orders of being submitted
        self.broker._submit(order.ref)
        if stopside is not None:  # don't make price on stopside mandatory
            self.broker._submit(stopside.ref)
        if takeside is not None and takeside.price is not None:
            self.broker._submit(takeside.ref)

        return order```

@Alexandre-Durand

I have a system that provides some functionality that you are after by storing all critical variables, trade data, account data in an *.ini file which is updated on each loop of next(). While this is not exactly what you might be after, it may overcome your problem until a better solution can be found.

How my system works on initial start:

• Parent program
  • Creates *.ini file
  • Runs BT as subprocess
  • BT starts normally

When connection fails

• notify_store receives error
• wait for connection to be restored (but BT does not resume)
  • send sms alerting me of restart
  • try send close position and try cancel stop loss (if any are open). API still receives these commands even when BT cannot resume.
  • runstop BT
• write variable to ini file signalling shutdown (this is for the parent program to read and action)

When shutdown recognised by parent program

• kill BT
  -reload BT

When BT reloads

• check if fresh start or reload.
  • If reload, then init with variables from last loop of next() prior to shutdown
  • If fresh start, init with normal defaults
  • [Option here to recreate the positions that had to been closed when BT failed so that the strategy can continue depending on how much time and price has moved]

Here is some sample code:

NOTIFY_STORE

def notify_store(self, msg, *args, **kwargs):

    print('*' * 5, 'STORE NOTIF:', msg)
    
    try:
        if 'external transaction MARKET_ORDER' in msg:
            print('msg = external transaction')
            
            self.hitstoploss = 0
            
            try:
                cancel = self.cancel(self.stop_ord) #CANCEL STOP LOSS
                print('CANCEL STOP LOSS')
                return
                
            except AttributeError:
                print('NO STOP LOSS TO CANCEL')
                return
                
            else:
            
                print('NOT SURE IF STOP LOSS CURRENTLY OPEN')
                try:
                    message = SendSMS.client.messages.create(
                        from_='+xxxxxxxxxx',
                        to='+xxxxxxxxxx',
                        body=(self.productcode + ' FAILED TO CANCEL STOP LOSS: CHECK ON PLATFORM'))
                except:
                    pass
                return

    except:
            
        print('CONNECTION FAILED')
        
        print('SEND SMS')
                    
        x = 1
        while True: #IF INTERNET CONNECTION DOWN. WAIT UNTIL ABLE TO SEND SMS BEFORE COMMENCING RELOAD
            try:
                
                message = SendSMS.client.messages.create(
                    from_='+xxxxxxxxxx',
                    to='+xxxxxxxxxx',
                    body=('SHUT DOWN: CLOSING POSITIONS & RELOADING'))
#                        body=(self.productcode + ' SHUT DOWN: CLOSING POSITIONS & RELOADING: {}'.format(msg)))

                print('SMS SENT')
                break
            except:
                print('!!! CONNECTION BROKEN !!! - FAILED TO SEND SMS. RETRYING #' + str(x))
                time.sleep(2)
                x = x + 1
                pass
        
        print('GET POSITION SIZE FROM INI FILE')
        #READ INI TO GET POSTION SIZE. CANNOT GET POSITION SIZE FROM BROKER IF CONNECTION INTERUPTED
        bt_file.read_trade_ini(self)
        time.sleep(2)
        print('INI FILE READ')
        print('POSITION SIZE: ' + str(self.position_size)) #self.position_size IS READ FROM THE INI FILE AND GETS UPDATED ON EACH next()
       
        print('TRY TO CLOSE POSITION')
        time.sleep(10)
        try:
           self.close(size=self.position_size) #SEND A CLOSE ORDER. THIS WILL WORK IF API CONNECTION RE-ESTABLISHED, EVEN IF BT HAS STALLED
        except:
            pass
#            time.sleep(2)
        print('POSITION CLOSED. TRY TO CANCEL STOP LOSS')
        try:
            self.cancel(self.stop_ord) #SEND A CANCEL STOP LOSS ORDER. THIS WILL WORK IF API CONNECTION RE-ESTABLISHED, EVEN IF BT HAS STALLED
        except:
            pass
        print('CANCEL STOP LOSS')

        time.sleep(2)
        bt_file.reload_write(self)    #CREATE SHUTDOWN TRIGGER IN INI FILE FOR PARENT PROGRAM TO RECEIVE
        time.sleep(2)
        print('STOPPING BACKTRADER')
        self.env.runstop()  #SHUT DOWN BACKTRADER
        time.sleep(1)
        press('enter')  #MUST KEEP CURSOR ACTIVE ON THE TERMINAL FOR THIS TO WORK
        return

PARENT PROGRAM

***FRESH START***

    #----- ESTABLISH INI FILE -----#

    config = configparser.ConfigParser()
    home = os.path.expanduser('~') #USER DIRECTORY
    filename = pc + '.ini'
    
    if not os.path.exists(home + '/00_config/' + filename):
        print('CREATING NEW INI FILE')
        f = open(home + '/00_config/' + filename, 'w')
    else:
        print('EXISTING INI FILE')
        pass
    
    myfile = Path(home + '/00_config/' + filename)
    
    config.read(myfile)
    section_00 = pc
    section_01 = pc + '-01'
    section_02 = pc + '-02'
    
    time.sleep(1)
    
    #----- CLEAR INI FILE -----#
    print('PREPARING INI FILE')
    with open(myfile,'r+') as s:
        config.read_file(s)
        config.remove_section(section_00)
        config.remove_section(section_01)
        config.remove_section(section_02)
        s.seek(0)
        config.write(s)
        s.truncate()
        
    time.sleep(1)
    #----- CREATE RELOAD SECTIONS IF THEY DO NOT EXIST -----#
    try:
        config.get(section_01, 'override')
    except:
#    except configparser.NoSectionError:
        config.add_section(section_01)   #ADD NEW SECTION
    
    #CREATE ACCOUNT SECTION IF IT DOES NOT EXIST
    try:
        config.get(section_02, 'account')
    except:
#    except configparser.NoSectionError:
        config.add_section(section_02)
        
    #CREATE TRADE DATA SECTION IF IT DOES NOT EXIST
    try:
        config.get(pc, 'tradeid')
    except:
#    except configparser.NoSectionError:
        config.add_section(pc)
    
    #----- RELOAD DEFAULT VALUES -----#
    config.set(section_01, 'override','0')
    config.set(section_01, 'reload','0')
    config.set(section_02, 'account','0')
    config.write(myfile.open('w'))

  
    #----- LOAD CEREBRO -----#
    cerebro(pc) #LOADS BT ('pc' refers to product code that is passed to BT from the parent)

***LOOP CHECKS ON INI FILE***

    while True:

#----- CONNECTION FAILURE - RELOAD -----#

        config.read(myfile)
        reload_sc = config.get(section_01,'reload')

        if reload_sc == 'SHUTDOWN': #IF INI FILE SAYS 'SHUTDOWN' (WHICH IS SET BY NOTIFY_STORE), THEN...
        
            print('KILL CEREBRO')
            #use to have a kill.subprocess command in here but it seemed redundant but might be useful if running multiple instances on one machine
            time.sleep(1)
            print('RELOAD CEREBRO')
            time.sleep(2)
            cerebro(pc)

        else:
            pass

BT

***FRESH START***

def __init__():

        ini_transfer.reload_read(self) #Loads ini file

        if self.reload_sc == 'SHUTDOWN': #If reloaded set as'SHUTDOWN' then init with last values, not default
            ini_transfer.read_restart_data(self) 
        else:
            vars(self) #This is just a method contain a group of variables

SAMPLE CODE FROM INI_TRANSFER

    def read_restart_data(self):
        args = parse_args()
        config = configparser.ConfigParser()
        home = os.path.expanduser('~')
        myfile = Path(home + '/00_config/' + args.data0 + '.ini')
        config.read(myfile) #path of your .ini file
        
        self.tradeid = config.get(args.data0,'tradeid')
        self.position_size = float(config.get(args.data0,'position_size'))
        self.freezebar = float(config.get(args.data0,'freezebar'))
        self.enter_price = float(config.get(args.data0,'enter_price'))
        self.retracement = float(config.get(args.data0,'retracement'))
        self.hitstoploss = int(config.get(args.data0,'hitstoploss'))
        self.high_2 = float(config.get(args.data0,'high_2'))
        self.low_2 = float(config.get(args.data0,'low_2'))
        self.high_3 = float(config.get(args.data0,'high_3'))
        self.pos_long = int(config.get(args.data0,'pos_long'))
        self.pos_short = int(config.get(args.data0,'pos_short'))
        self.stop_position = float(config.get(args.data0,'stop_position'))
        self.trend_backflip = float(config.get(args.data0,'trend_backflip'))
        self.trend_exit_trigger = float(config.get(args.data0,'trend_exit_trigger'))
        self.false_signal = float(config.get(args.data0,'false_signal'))
        self.RTH = int(config.get(args.data0,'RTH'))
        self.trend_exit_price = float(config.get(args.data0,'trend_exit_price'))
        self.break_out_long = float(config.get(args.data0,'break_out_long'))
        self.break_out_short = float(config.get(args.data0,'break_out_short'))

Perhaps some of this might assist you with new ideas to tackle your problem.

Also appreciate if anyone has ideas on how to improve or simplify this?

Not being from a coding background, I am making this up as I go. No doubt there are more efficient ways of achieving some of the things I am doing.

TURNING OFF PLOTTING 'LINESCOUPLER'

Once you have lines coupled, but you do not want to show the lines when plotting, turn them off using this:

#data0 = lower timeframe
#data1 = higher timeframe


def __init__():
     #data1 Bollinger Bands
     self.boll = bb_lc = bt.indicators.BollingerBands(self.data1, period=self.p.bbperiod, devfactor=self.p.devfactor, plot=True)

     #Line Coupling used on Bollinger Bands
     bb_lc1 = bb_lc()

     #Turn off plotting of LinesCoupler
     bb_lc1.plotinfo.plot = False

More options on plotting:
https://www.backtrader.com/docu/plotting/plotting/

SOLVED

Never underestimate the power of perseverance.

The following is my modified notify_store(). This is tested with OANDA.

What it does:

• If a manual trade occurs via the broker platform with 'external transaction MARKET_ORDER' then try to cancel stop_loss if one exists.

• All other notify_store errors:

  • Try to send sms alert (using Twillio account) with error to my mobile
  • Get position size from my *ini file (Note: on each cycle through next() I store critical system/trade data in an *.ini file). Position is queried from *.ini instead of broker because connection may not allow getting position from broker
  • Try close order with position size
  • Try cancel stop loss
  • Write SHUTDOWN signal to *ini file to let parent program know BT has failed
  • Stop BT

• The parent program will see that BT (as a subprocess) has failed and shut down. It will kill the BT subprocess and reload it.

• BT reloads and during __init__ looks to see if there is already existing system/trade data in the *.ini file. If True then the old system/trade data is reloaded, otherwise a fresh start is required.

import backtrader as bt
import signal
from keyboard import press
from actions.sms_send import SendSMS
from ini.ini_reader import bt_file

def notify_store(self, msg, *args, **kwargs):

    print('*' * 5, 'STORE NOTIF:', msg)

    
    if 'external transaction MARKET_ORDER' in msg:
        print('msg = external transaction')

        try:
            cancel = self.cancel(self.stop_ord) #CANCEL STOP LOSS
            print('CANCEL STOP LOSS')
            return
            
        except AttributeError:
            print('NO STOP LOSS TO CANCEL')
        returnsdg
            
        else:
        
            print('NOT SURE IF STOP LOSS CURRENTLY OPEN')
            message = SendSMS.client.messages.create(
                from_='+xxxxxxxxxx',
                to='+xxxxxxxxxx',
                body=('FAILED TO CANCEL STOP LOSS: CHECK ON PLATFORM'))
            return
            
    else:
        print('CONNECTION FAILED')
        
        print('SEND SMS')
        try:
            message = SendSMS.client.messages.create(
                from_='+xxxxxxxxxx',
                to='+xxxxxxxxxx',
                body=('SHUT DOWN: CLOSING POSITIONS & RELOADING: {}'.format(msg)))
        except:
            pass
        print('SMS SENT')
        
        print('GET POSITION SIZE FROM INI FILE')
        time.sleep(2)
        #READ INI TO GET POSTION SIZE. CANNOT GET POSITION SIZE FROM BROKER IF CONNECTION INTERUPTED
        bt_file.read_trade_ini(self)
        time.sleep(2)
        print('INI FILE READ')
        print('POSITION SIZE: ' + str(self.position_size)) #self.position_size IS READ FROM THE INI FILE AND GETS UPDATED ON EACH next()
       

        print('TRY TO CLOSE POSITION')
        time.sleep(2)
        try:
           self.close(size=self.position_size) #SEND A CLOSE ORDER. THIS WILL WORK IF API CONNECTION RE-ESTABLISHED, EVEN IF BT HAS STALLED
        except:
            pass
        time.sleep(2)
        print('POSITION CLOSED. TRY TO CANCEL STOP LOSS')
        try:
            self.cancel(self.stop_ord) #SEND A CANCEL STOP LOSS ORDER. THIS WILL WORK IF API CONNECTION RE-ESTABLISHED, EVEN IF BT HAS STALLED
        except:
            pass
        print('CANCEL STOP LOSS')

    
        time.sleep(2)
        bt_file.reload_write(self)    #CREATE SHUTDOWN/RELOAD TRIGGER IN INI FILE FOR PARRENT PROGRAM TO RECEIVE
        time.sleep(2)
        print('STOPPING BACKTRADER')
        self.env.runstop()  #SHUT DOWN BACKTRADER
        press('enter')
        return #EXIT BACKTRADER

What other ideas have people used to deal with connection failures?

WORKING
I have setup notify_store to clear stop orders when I manually close a position using the brokers platform. This works.

NOT WORKING
I want to send close positions and open orders when a connection has failed. I often found that the system continues to send orders after a time out even through BT has stopped. This can result in accumulated positions.

When either a 'Connection Failed' or 'Timed Out' is received by notify_store, I'd like to run through the process shown below:

• read my *.ini file to find position size prior to connection issue
• send a close order
• send a cancel stop loss
• write to *.ini file to signal connection failed
• runstop

I've test the sequence above by placing it under if 'external transaction MARKET_ORDER' in msg: and it works. It reads ini file, closes positions, writes ini file and then reloads cerebro as a subprocess in the parent program. However, when it is placed in if 'V20ConnectionError' in msg: or if 'timed out' in msg: I receive the following error:

if 'external transaction MARKET_ORDER' in msg:
TypeError: argument of type 'V20ConnectionError' is not iterable

Is this not possible, or does it need to be used as a callback (which I'm not familiar using)?

Appreciate any thoughts you have.

NOTIFY_STORE CODE:

def notify_store(self, msg, *args, **kwargs):

    print('*' * 5, 'STORE NOTIF:', msg)

    ### IF MANUAL CLOSE TRADE VIA PLATFORM, THEN CANCEL STOP LOSS --- THIS WORKS
    
    if 'external transaction MARKET_ORDER' in msg:
        print('msg = external transaction')

        try:
            cancel = self.cancel(self.stop_ord) #CANCEL STOP LOSS
            print('CANCEL STOP LOSS')
            return
            
        except AttributeError:
            print('NO STOP LOSS TO CANCEL')
            return
            
        else:
            print('NOT SURE IF STOP LOSS CURRENTLY OPEN')
            return


    ### CONNECTION FAILED --- THIS DOES NOT WORK
    
    if 'V20ConnectionError' in msg:
    
        print('CONNECTION FAILED')
        
        #READ INI FILE TO GET POSTION SIZE
        bt_file.read_trade_ini(self)
        
        print('TRY TO CLOSE POSITION')
        self.close(size=self.position_size)
        print('POSITION CLOSED. TRY TO CANCEL STOP LOSS')
        self.cancel(self.stop_ord)
        print('CANCEL STOP LOSS')

        bt_file.reload_write(self)    #CREATE SHUTDOWN & RELOAD TRIGGER IN INI FILE
        
        print('STOPPING BACKTRADER')
        self.env.runstop()
        press('enter')
        return
        
        
        
    if 'timed out' in msg: ### TIMED OUT --- THIS DOES NOT WORK
    
        print('TIMED OUT')
        
        #READ INI FILE TO GET POSTION SIZE
        bt_file.read_trade_ini(self)
        
        print('TRY TO CLOSE POSITION')
        self.close(size=self.position_size)
        print('POSITION CLOSED. TRY TO CANCEL STOP LOSS')
        self.cancel(self.stop_ord)
        print('CANCEL STOP LOSS')
    
        bt_file.reload_write(self)    #CREATE SHUTDOWN & RELOAD TRIGGER IN INI FILE
        print('STOPPING BACKTRADER')
        self.env.runstop()
        press('enter')
        return

@ab_trader Thanks for the info.

Working indicator with two conditions (open and close > bb.mid).

import backtrader as bt
import backtrader.indicators as btind


class AboveBBmid(bt.Indicator):

    lines = ('open', 'close')
    params = (
        ('period', 15),  # how many to consider
        ('ago', 0),  # offset to start in the past
        ('bbperiod', 20),  # offset to start in the past
        ('devfactor', 2),  # offset to start in the past
    )

    def __init__(self):
        
        self.bollband = bt.indicators.BollingerBands(self.data, period=self.p.bbperiod, devfactor=self.p.devfactor, plot=False)
        
        bar_open = [self.data.open(-i) > self.bollband.lines.mid(-i) for i in range(self.p.ago, self.p.ago + self.p.period)]
        
        self.lines.open = bt.All(*bar_open)

        bar_close = [self.data.close(-i) > self.bollband.lines.mid(-i) for i in range(self.p.ago, self.p.ago + self.p.period)]
        
        self.lines.close = bt.All(*bar_close)
        
        self.combined = bt.And(self.lines.open, self.lines.close)

QUESTION

How do I add multiple conditions in the for loop?

PROBLEM

I want to check if both open and close are above bollinger-mid. I know the below code is incorrect but hopefully it shows what I am trying to achieve.

INDICATOR

class OpenAndCloseAboveBBmid(bt.Indicator):

    lines = ('consecutive',)
    params = (
        ('period', 15),  # how many to consider
        ('ago', 0),  # offset to start in the past
        ('bbperiod', 20),  # offset to start in the past
        ('devfactor', 2),  # offset to start in the past
    )

    def __init__(self):
        
        self.bollband = bt.indicators.BollingerBands(self.data, period=self.p.bbperiod, devfactor=self.p.devfactor, plot=False)
        
        ### I KNOW THIS NEXT LINE WON'T WORK BUT IT SHOWS WHAT I AM TRYING TO ACHIEVE
        incs = [self.data.open(-i) > self.bollband.lines.mid(-i) and self.data.close(-i) > self.bollband.lines.mid(-i) for i in range(self.p.ago, self.p.ago + self.p.period)]
        
        self.lines.consecutive = bt.All(*incs)

@barton05 said in 3 Black Crows / 3 White Soldiers:

bt.talib

Must be a new addition since the backtrader website was developed. It isn't listed on the BT website.

https://www.backtrader.com/docu/talibindautoref/

Quite a few other great indicators in the ta-lib library too:

https://github.com/mrjbq7/ta-lib

Thanks for pointing this out.