I have the following code.

p1 = close
tp = p1 - (10 * atr)
sp = p1 + (4 * atr)
trail = (3 * atr)
# Parent
            self.order = self.sell(exectype=bt.Order.Limit,
                                   size=size,
                                   price=p1,
                                   tif='GTD',
                                   goodTillDate=gtd.strftime('%Y%m%d %H:%M:%S GMT'),
                                   account=self.account,
                                   transmit=False)

            logging.info('{}: Oref {} / Sell at {}'.format(self.datetime.date(), self.order.ref, p1))

            # Take Profit
            oT = self.buy(exectype=bt.Order.Limit,
                          price=tp,
                          # valid=valid3,
                          account=self.account,
                          parent=self.order,
                          size=self.order.size,
                          transmit=False)

            logging.info('{}: Oref {} / Buy TP Limit at {}'.format(self.datetime.date(), oT.ref, tp))

            # Stop Trail Limit
            o3 = self.buy(exectype=bt.Order.StopTrailLimit,
                          price=p1,
                          plimit=sp,
                          trailamount=trail,
                          account=self.account,
                          parent=self.order,
                          size=self.order.size,
                          transmit=True)

When I execute. I get an error saying "You must specify one value: Limit Price or Limit Price Offset Value.

This is on IBKR. I do not specify the limit price offset. Does anyone see the issue?

I have the following order with a stop-loss attached. The problem is the Buy Limit order will be reverse the position from Short -> Long; But I need the Stop-Loss size should be for the balance.

Example
Current Position -2 (short)
Buy 4 (long)
New Position 2 (long)
StopLoss Order is 4. I'm passing in the size 2. But somehow this is getting overwritten.

Does anyone know how to fix this? I don't want to submit an order to close the existing position and then open a new order.

self.order = self.buy(exectype=bt.Order.Limit,
                                  size=size,
                                  price=p1,
                                  tif='GTD',
                                  goodTillDate=gtd.strftime('%Y%m%d %H:%M:%S GMT'),
                                  account=self.account,
                                  transmit=False)

o2 = self.sell(exectype=bt.Order.Stop,
                           price=sp,
                           valid=valid2,
                           account=self.account,
                           parent=self.order,
                           size=stop_size,  # We want the stop loss to be half our position; meaning don't reverse
                           transmit=True)

            logging.info('{}: Oref {} / Sell Stop at {}'.format(self.datetime.date(), o2.ref, sp))

A new Renko class was created and I stopped using the RenkoFilter. The new Renko class didn't inherit from bt.Indicator as this open up a bunch of other issues. If you need it please fill free to ping me. I'll open it up once I get a few more unit tests around it.

I found a solution to the problem.

1. You need to group the order in the parent-child relationship (this open up other issues, but another ticket for this)
2. Using the ib_insync library to get API access to IBKR directly. Call the reqGlobalCancel(). IBKR has a security feature where the clientID who opens the order must cancel the order. The reqGlobalCancel function gets around that.

I'm creating a new Renko Indicator to address the issues (i.e. not based on the actual price movement, atr) ...
https://community.backtrader.com/topic/511/renko-bricks/17
https://community.backtrader.com/topic/1694/filter-on-replaydata/4.

class Renko(bt.Indicator):
    '''
    During a trend continuation, a new brick of the same color is added to the chart when the Renko Brick Size value,
    plus one tick is met. A reversal in the Renko trend and the formation of a different color brick is formed
    when price surpasses the Renko Brick Size parameter by twice the size plus one tick.

    Formula:
        atr  = SmoothedMovingAverage(TrueRange, period)
        open = open
        high = (close + size)
        low  = (close - size)
        close = close
        direction = Sum(up) - Sum(down) Notes: Neutral = 0, Up = 1, Down = -1

    See also:
        https://school.stockcharts.com/doku.php?id=chart_analysis:renko
    '''

    lines = ('open', 'high', 'low', 'close', 'volume', 'direction')

    '''
        Fixed = Fixed Brick Size, False, means ATR
    '''
    params = (('fixed', True), ('brick_size', 0.0001), ('period', 14), ('field', 'close'), ('movav', MovAv.Smoothed))

    plotinfo = dict(subplot=False)

    def __init__(self):
        o = self.data.open
        h = self.data.high
        l = self.data.low
        c = self.data.close
        v = self.data.volume

        up_count = {}
        down_count = {}
       
        # Due we need to keep track of all Bricks with OHLCV to push to Strategy after time resolution?
        total_bricks = {}

        (brick_lower_limit, brick_upper_limit) = (c - self.p.brick_size, c + self.p.brick_size)

        self.lines.atr = ATR(self.data, period=self.p.period, movav=self.p.movav)
        self.lines.close = c
        self.lines.open = o
        self.lines.high = c + self.p.brick_size
        self.lines.low = c - self.p.brick_size
        self.lines.volume = v
        self.lines.direction = sum(self.up_count) - sum(self.down_count)

        super(Renko, self).__init__()

    def prenext(self):
        print('prenext:: current period:', len(self))

    def nextstart(self):
        print('nextstart:: current period:', len(self))
        # emulate default behavior ... call next
        self.next()

    def next(self):
        print('next:: current period:', len(self))

    def _plotlabel(self):
        plabels = [self.p.period]
        plabels += [self.p.movav] * self.p.notdefault('movav')
        return plabels

Test Cases

1. 1-minute resolution, fixed size = 1, direction=1 (upward), price movement= 3 => Expectation = 3 green (up) bricks
2. 1-minute resolution, fixed size = 1, direction=1, price movement = -2 => Expectation = 0 bricks; not enough price movement when changing direction
3. 1-minute resolution, fixed size = 1, direction=1, price movement = -2.1 => Expectation = 2 red (down) bricks

I need the Strategy to expose all three bricks in the Next(self) would need access to all three bricks given that the resolution is 1 minute.

Is this the correct implementation strategy? What will be the issues around time resolutions?

I had thought about just sampling at a lower resolution, which would capture the price movements and push out the bars. However, we would still need a custom Renko indicator to address the up/down logic.

I have a question with regards to bracket orders and the reversal of a position. I would expect the existing stop and limit order associated with the Short (parent) order to be canceled when the position changes to Long. But this isn't happening and wondering if they're existing a setting I might be missing?

I found the bug. I turned on _debug=true and was able to see the issue. The realtimebars were coming in as I expected.

The algorithm seems to run one, but I never get another next called. What I'm I missing? After the first trade, I would expect to see the holding... to continue to happen in the console until the next trade is triggered.

def runstrats(args=None):
    args = parse_args(args)

    cerebro = bt.Cerebro(stdstats=True)

    fromdate = None
    if args.fromdate:
        dtformat = '%Y-%m-%d' + ('T%H:%M:%S' * ('T' in args.fromdate))
        fromdate = datetime.datetime.strptime(args.fromdate, dtformat)

    todate = None
    if args.todate:
        dtformat = '%Y-%m-%d' + ('T%H:%M:%S' * ('T' in args.todate))
        todate = datetime.datetime.strptime(args.todate, dtformat)

    # This is the Interactive Broker client
    store = ibstore.IBStore(host='127.0.0.1', # env('IB_URL'),
                            port=7496, # env('IB_PORT'),
                            clientId=35,
                            notifyall=True
                            # _debug=True
                            )

    # Add Data
    data0 = store.getdata(dataname=ib_symbol,
                          timeframe=bt.TimeFrame.Minutes,
                          fromdate=fromdate,
                          todate=todate,
                          compression=1,
                          rtbar=True)

    # Resample Data
    cerebro.resampledata(data0,
                         timeframe=bt.TimeFrame.Minutes,
                         compression=1
                         )

    data0.addfilter(bt.filters.Renko, size=0.0001)
    cerebro.adddata(data0)

    # Set the behavior
    cerebro.signal_accumulate(False)
    cerebro.signal_concurrent(False)

    # Broker
    cerebro.broker = store.getbroker()
    cerebro.broker.setcommission(commission=2.47, margin=2000.0, mult=10.0)

    # Sizer
    cerebro.addsizer(bt.sizers.FixedReverser, stake=5)

    # Observer
    cerebro.addobserver(bt.observers.FundValue)

    # Strategy
    cerebro.addstrategy(TwoBlock, **eval('dict(' + args.strat + ')'))

    # Execute
    kwargs = dict(stdstats=True)
    kwargs.update(**eval('dict(' + args.cerebro + ')'))
    cerebro.run(**kwargs)

Output below

Server Version: 76
TWS Time at connection:20200901 17:04:03 Central Standard Time
01-Sep-20 17:04:06 INFO      holding...
01-Sep-20 17:05:03 INFO      holding...
01-Sep-20 17:06:02 INFO      holding...
01-Sep-20 17:07:02 INFO      holding...
01-Sep-20 17:08:03 INFO      holding...
01-Sep-20 17:09:03 INFO      holding...
01-Sep-20 17:10:03 INFO      Buying position
01-Sep-20 17:10:03 INFO      2020-09-01: Oref 1 / Buy at 1.19185
01-Sep-20 17:10:03 INFO      2020-09-01: Oref 2 / Sell Stop at 1.1911500000000002
01-Sep-20 17:10:03 INFO      2020-09-01: Oref 3 / Sell TP Limit at 1.2016
01-Sep-20 17:10:03 INFO      2020-09-01: Oref 4 / Sell Tail STOP 0.06
01-Sep-20 17:11:03 INFO      2020-09-01: Order ref: 1 / Type Buy / Status Submitted
01-Sep-20 17:11:03 INFO      ORDER ACCEPTED/SUBMITTED 01/09/1970, 12:54:29
01-Sep-20 17:11:03 INFO      2020-09-01: Order ref: 2 / Type Sell / Status Submitted
01-Sep-20 17:11:03 INFO      ORDER ACCEPTED/SUBMITTED 01/09/1970, 12:54:29
01-Sep-20 17:11:03 INFO      2020-09-01: Order ref: 3 / Type Sell / Status Submitted
01-Sep-20 17:11:03 INFO      ORDER ACCEPTED/SUBMITTED 01/09/1970, 12:54:29
01-Sep-20 17:11:03 INFO      2020-09-01: Order ref: 4 / Type Sell / Status Submitted
01-Sep-20 17:11:03 INFO      ORDER ACCEPTED/SUBMITTED 01/09/1970, 12:54:29