Hi,

I am trying to change the rollover class to use it with input data feeds added in cerebro. I guess in this case next for the data feeds is also called by cerebro and thus no need to be called within rollover. I wonder how I can check for the end of the data feed without using the check for _next being False.

Many thanks

cerebro.setbroker(<instance of your broker class>)

Haven't tested it, but I think your csv file looks more like the following.

params = (
# ('nullvalue', float('NaN')),
('dtformat', '%Y-%m-%d %H:%M:%S'),
('datetime', 5),
('Open', 0),
('High', 1),
('Low', 2),
('Close', 3),
('Volume', 4),
)

Without having tested it, perhaps you can use in next of strategy B self.cerebro.runningstrats[self._id ^ 1] to get access to strategy A

I guess by filters you mean indicators and not data filters. This is an example having a list of indicators (in this case SimpleMovingAverage applied on close), one per data feed.

class TestStrategy(bt.Strategy):

    params = (
        ('maperiod', 15),
    )

    def __init__(self):
        self.smas = []
        for d in self.datas:
            self.smas.append(bt.indicators.SimpleMovingAverage(d.lines.close, period=self.params.maperiod))

I even like better the _nextforce = True pointed out to me by @backtrader some time ago.

class CustomIndicator(bt.Indicator):
    _nextforce = True
...

Another solution that does not use cheat on open. It is a cheat-on-close broker and you buy on open by disabling the coc and sell on close by enabling it.

class TestStrategy(bt.Strategy):

    def next(self):
        order1 = self.close(self.datas[0], coc=True)
        order2 = self.buy(self.datas[0], coc=False)

if __name__ == '__main__':
    cerebro = bt.Cerebro()
    cerebro.broker.set_coc(True)
    ....

The strategy can turn on/off a parameter of the indicator according to whether in trade or not. Have a look at the dynamic indicator example
https://www.backtrader.com/blog/posts/2018-02-06-dynamic-indicator/dynamic-indicator.html

I am trying to generate a dynamically changing data feed based on the RollOver class but it does not work always correctly when trying to update the history at the same time (self.params.update_history_upon_roll set to True). For example when moving to a data feed with longer history it gives wrong results. Any ideas?

Thanks

    def _roll(self):
        if self._ds:
            clock1 = self.lines[0].lencount
            self._dexp = self._d
            self._d = self._ds.pop(0)
            self._dts.pop(0)
            clock3 = self._d.lines[0].lencount
            if self.params.update_history_upon_roll:
                if clock3 < clock1:
                    self._d.lines.rewind()
                for i in range(len(self.lines.lines)):
                    self.lines[i].array = self._d.lines[i].array[:]
                    self.lines[i].lencount = self._d.lines[i].lencount
                    self.lines[i].idx = self._d.lines[i].idx
                if clock3 < clock1:
                    self.lines.advance()
            return True
        else:
            return False

    def _load(self):
        while self._d is not None:
            if self._doroll:
                self._roll()
                self._doroll = False
            _next = self._d.next()
            if _next is None:  # no values yet, more will come
                continue
            if _next is False:  # no values from current data src
                if self._ds:
                    self._d = self._ds.pop(0)
                    self._dts.pop(0)
                else:
                    self._d = None
                continue

            dt0 = self._d.datetime.datetime()  # current dt for active data

            # Synchronize other datas using dt0
            for i, d_dt in enumerate(zip(self._ds, self._dts)):
                d, dt = d_dt
                while dt < dt0:
                    if d.next() is None:
                        continue
                    self._dts[i] = dt = d.datetime.datetime()

            # Move expired future as much as needed
            while self._dexp is not None:
                if not self._dexp.next():
                    self._dexp = None
                    break

                if self._dexp.datetime.datetime() < dt0:
                    continue

            if self._dexp is None and self._checkdate(dt0, self._d):
                # rule has been met ... check other factors only if 2 datas
                # still there
                if self._ds and self._checkcondition(self._d, self._ds[0]):
                    if self.params.upon_condition:
                        self._roll()
                    else:
                        self._doroll = True

            # Fill the line and tell we die
            for i in range(len(self.lines.lines)):
                self.lines[i][0] = self._d.lines[i][0]

            return True

        # Out of the loop -> self._d is None, no data feed to return from
        return False

Hi,

if there are multiple trades on different products, then pnlplus and pnlminus in Trades observer will hold just the pnl of the last trade traversed.

    def next(self):
        for trade in self._owner._tradespending:
            if trade.data not in self.ddatas:
                continue

            if not trade.isclosed:
                continue

             if trade.pnl >= 0:
                self.lines.pnlplus[0] =  trade.pnl
            else:
                self.lines.pnlminus[0] =  trade.pnl

I guess something like this is needed

    def next(self):
        for trade in self._owner._tradespending:
            if trade.data not in self.ddatas:
                continue

            if not trade.isclosed:
                continue

            if trade.pnl >= 0:
                self.lines.pnlplus[0] = np.nansum([self.lines.pnlplus[0], trade.pnl])
            else:
                self.lines.pnlminus[0] = np.nansum([self.lines.pnlminus[0], trade.pnl])

I am using version 1.9.70.122 in case that is relevant.

Cheers