Backtrader Community

hbf

@ab_trader Sorry what do you mean by provider info? Are you referring to where the DDE feed is sourced from? If so, it is a program called "Spark" by Iguana 2.

hbf

Hi Community,

We are currently in the process of testing a system that involves analysing data from ~200 securities. Interactive Brokers has historical download request limits that are hindering the ability to keep the system running without user interaction.

Recently, we have stumbled across a data provider that we are using for something else which allows access to ASX market data via a Dynamic Data Exchange.

Unfortunately, we do not have sufficient programming experience to know whether or not it is possible to incorporate the DDE into the Backtrader environment. Ideally, we would like to use the DDE data for analysis and execute through Interactive Brokers.

Any thoughts or discussion on this matter would be greatly appreciated. Thank you.

hbf

Thank you very much! This appears to have solved the issue.

hbf

I hope this can help others that wish to implement a multi time-frame and asset strategy.

I am having problems with the strategy actually running for what seems to be higher timeframe/compression combinations.

When I run the code below with arguments --compression0 2 --timeframe1 minute --compression1 5 the strategy works as intended and I am receiving the signal output during the backfill process.

Server Version: 76
TWS Time at connection:20190104 14:37:53 AEST
***** EUR.USD-CASH-IDEALPRO-60m DATA NOTIF: DELAYED
***** GBP.USD-CASH-IDEALPRO-60m DATA NOTIF: DELAYED
***** GBP.AUD-CASH-IDEALPRO-60m DATA NOTIF: DELAYED
2019-01-03T10:00:00 EUR.USD-CASH-IDEALPRO-1d signal: none
2019-01-03T10:00:00 GBP.USD-CASH-IDEALPRO-1d signal: none
2019-01-03T10:00:00 GBP.AUD-CASH-IDEALPRO-1d signal: none
2019-01-03T10:02:00 EUR.USD-CASH-IDEALPRO-1d signal: buy
2019-01-03T10:02:00 GBP.USD-CASH-IDEALPRO-1d signal: buy
2019-01-03T10:02:00 GBP.AUD-CASH-IDEALPRO-1d signal: sell
...
2019-01-03T22:36:00 EUR.USD-CASH-IDEALPRO-1d signal: buy
2019-01-03T22:36:00 GBP.USD-CASH-IDEALPRO-1d signal: buy
2019-01-03T22:36:00 GBP.AUD-CASH-IDEALPRO-1d signal: sell
***** EUR.USD-CASH-IDEALPRO-60m DATA NOTIF: LIVE
***** GBP.USD-CASH-IDEALPRO-60m DATA NOTIF: LIVE
***** GBP.AUD-CASH-IDEALPRO-60m DATA NOTIF: LIVE
2019-01-03T22:38:00 EUR.USD-CASH-IDEALPRO-1d signal: buy
2019-01-03T22:38:00 EUR.USD-CASH-IDEALPRO-60m signal: buy order id: 1
2019-01-03T22:38:00 GBP.USD-CASH-IDEALPRO-1d signal: buy
2019-01-03T22:38:00 GBP.USD-CASH-IDEALPRO-60m signal: buy order id: 2
2019-01-03T22:38:00 GBP.AUD-CASH-IDEALPRO-1d signal: sell
2019-01-03T22:38:00 GBP.AUD-CASH-IDEALPRO-60m signal: sell order id: 3

However, when using the same code with arguments --compression0 60 --timeframe1 daily --compression1 1, backtrader connects to the broker but fails to produce any of the signals. The output below is all that is received and the strategy fails to execute (I have kept it running for multiple hours with no additional output). Running with debug shows that messages are being received from the broker, but nothing happens.

Server Version: 76
TWS Time at connection:20190104 14:37:15 AEST
***** EUR.USD-CASH-IDEALPRO-60m DATA NOTIF: DELAYED
***** GBP.USD-CASH-IDEALPRO-60m DATA NOTIF: DELAYED
***** GBP.AUD-CASH-IDEALPRO-60m DATA NOTIF: DELAYED
***** EUR.USD-CASH-IDEALPRO-60m DATA NOTIF: LIVE
***** GBP.USD-CASH-IDEALPRO-60m DATA NOTIF: LIVE
***** GBP.AUD-CASH-IDEALPRO-60m DATA NOTIF: LIVE

The above example works when using 1hr/1day historical data saved locally. I feel like this has to do with IB but my understanding is that 1 year of data is within the historical download limits (needed for 200 day moving average). Potentially there is a problem with using multiple assets?

I feel a bit stuck as I have been working on this for some time to no avail. I would appreciate if anyone has had any luck with the problems I am facing.

Thank you for your time!

from __future__ import (absolute_import, division, print_function,
                        unicode_literals)

import argparse
import datetime
import math

import pandas as pd
import backtrader as bt

class ParcelSizer(bt.Sizer):

    params = dict(stake=10000)

    def _getsizing(self, comminfo, cash, data, isbuy):
        sz = math.floor(self.p.stake / data.close[0])
        return int(sz)

class CFDSt(bt.Strategy):
    params = dict(
        smaperiod=200,
        rsiperiod=5,
        atrperiod=10,
    )

    def notify_order(self, order):
        if order.status == order.Submitted:
            return

        dt, dn = self.data.datetime.datetime(0).isoformat(), order.data._name
        print('{} {} Order {} Status {}'.format(
            dt, dn, order.ref, order.getstatusname())
        )

        if order.status == order.Completed:
            return

        whichord = ['main', 'stop', 'limit', 'close']
        if not order.alive():  # not alive - nullify
            dorders = self.o[order.data]
            idx = dorders.index(order)
            dorders[idx] = None
            print('{} {} Order no longer alive {} Ref'.format(dt, dn,
                                                              whichord[idx]))

            if all(x is None for x in dorders):
                dorders[:] = []  # empty list - New orders allowed

    def notify_trade(self, trade):
        dt, dn = self.data.datetime.datetime(0).isoformat(), trade.data._name
        if trade.isclosed:
            print('{} {} Gross Profit {} Net Profit {}' \
            .format(dt, dn, round(trade.pnl,2), round(trade.pnlcomm,2)))


    def __init__(self):
        self.o = dict()  # orders per data (main, stop, limit, manual-close)
        self.lendata = dict()
        self.inds = dict()

        for i, d in enumerate(self.datas):
            self.inds[d._name] = dict()
            self.inds[d._name]['sma'] = bt.indicators.SMA(d,
                                            period=self.p.smaperiod)
            self.inds[d._name]['signal'] = 'none'

    data_live = False

    def notify_data(self, data, status, *args, **kwargs):
        print('*' * 5, data._name ,'DATA NOTIF:', data._getstatusname(status),
              *args)
        if status == data.LIVE:
            self.data_live = True

    def nextstart(self):
        for i, d in enumerate(self.datas):
            self.lendata[d] = len(d)

    def next(self):
        for i, d in enumerate(self.datas):

            dt, dn = self.data.datetime.datetime(0).isoformat(), d._name
            if (i + 1) % 2 != 0:
                # every odd data feed (shorter timeframe first)
                pos = self.getposition(d).size # get position
                dnht = self.datas[i+1]._name # higher timeframe dataname

                print('{} {} signal: {}'.format(dt, dnht,
                    self.inds[dnht]['signal'])) # print the signal from the higher timeframe

                if self.inds[dnht]['signal'] == 'buy' and self.data_live:
                    self.o[d] = [self.buy(data=d)]
                    print('{} {} signal: {} order id: {}'.format(dt, dn,
                        self.inds[dnht]['signal'], self.o[d][0].ref))
                    self.inds[dnht]['signal'] = 'none' # reset signal

                elif self.inds[dnht]['signal'] == 'sell' and self.data_live:
                    self.o[d] = [self.sell(data=d)]
                    print('{} {} signal: {} order id: {}'.format(dt, dn,
                        self.inds[dnht]['signal'], self.o[d][0].ref))
                    self.inds[dnht]['signal'] = 'none'

                else:
                    pass

            else:
                # every even data feed (higher timeframe second)
                pos = self.getposition(self.datas[i-1]).size
                # position on smaller time frame
                dnlt = self.datas[i-1]._name # lower timeframe dataname

                if self.lendata[d] < len(d):
                    # new higher timeframe bar
                    self.lendata[d] += 1

                    if not pos and not self.o.get(self.datas[i-1], None):
                        # no orders/position
                        if d.close[0] < self.inds[dn]['sma'][0]:
                            self.inds[dn]['signal'] = 'sell'

                        elif d.close[0] > self.inds[dn]['sma'][0]:
                            self.inds[dn]['signal'] = 'buy'

                        else:
                            self.inds[dn]['signal'] = 'none'

                    else:
                        pass

def runstrat(args=None):

    args = parse_args(args)
    cerebro = bt.Cerebro()

    # Store
    store = bt.stores.IBStore(port=7497, host='127.0.0.1', _debug=args.debug,
                              notifyall=args.notifyall, reconnect=-1,
                              timeout=60)

    securities = ['EUR.USD-CASH-IDEALPRO','GBP.USD-CASH-IDEALPRO',
                  'GBP.AUD-CASH-IDEALPRO']

    tframes = dict(seconds=bt.TimeFrame.Seconds,
                   minute=bt.TimeFrame.Minutes, daily=bt.TimeFrame.Days,
                   weekly=bt.TimeFrame.Weeks, monthly=bt.TimeFrame.Months)

    for security, contract in zip(securities,contracts):
        data = store.getdata(dataname=security, tradename=contract,
                             timeframe=tframes[args.timeframe],
                             compression=int(args.compression))

        cerebro.resampledata(data, timeframe=tframes[args.timeframe0],
                             compression=int(args.compression0),
                             name=str(security+args.name0))

        cerebro.resampledata(data, timeframe=tframes[args.timeframe1],
                             compression=int(args.compression1),
                             name=str(security+args.name1))

    # Broker
    cerebro.broker = store.getbroker()

    # Strategy
    cerebro.addstrategy(CFDSt)

    # Sizer
    cerebro.addsizer(ParcelSizer)

    # Execute
    cerebro.run()

def parse_args(pargs=None):
    parser = argparse.ArgumentParser(
        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
        description=(
            'Multiple Values'
        )
    )

    parser.add_argument('--cerebro', required=False, default='',
                        metavar='kwargs', help='kwargs in key=value format')

    parser.add_argument('--debug', required=False,
                        default=False, action='store',
                        help='Debug parameter')

    parser.add_argument('--notifyall', required=False,
                        default=False, action='store',
                        help='If True, any error message sent by IB is relayed')

    parser.add_argument('--broker', required=False, default='',
                        metavar='kwargs', help='kwargs in key=value format')

    parser.add_argument('--sizer', required=False, default='',
                        metavar='kwargs', help='kwargs in key=value format')

    parser.add_argument('--strat', required=False, default='',
                        metavar='kwargs', help='kwargs in key=value format')

    parser.add_argument('--timeframe', required=False,
                        default='minute', action='store',
                        help='datafeed timeframe parameter')

    parser.add_argument('--compression', required=False,
                        default=5, action='store',
                        help='datafeed compression parameter')

    parser.add_argument('--timeframe0', required=False,
                        default='minute', action='store',
                        help='datafeed0 timeframe parameter (resampled)')

    parser.add_argument('--compression0', required=False,
                        default=60, action='store',
                        help='datafeed0 compression parameter (resampled)')

    parser.add_argument('--name0', required=False,
                        default='-60m', action='store',
                        help='datafeed0 name parameter (resampled)')

    parser.add_argument('--timeframe1', required=False,
                        default='daily', action='store',
                        help='datafeed1 timeframe parameter (resampled)')

    parser.add_argument('--compression1', required=False,
                        default=1, action='store',
                        help='datafeed1 compression parameter (resampled)')

    parser.add_argument('--name1', required=False,
                        default='-1d', action='store',
                        help='datafeed1 name parameter (resampled)')

    parser.add_argument('--asx', required=False,
                        default='20', action='store',
                        help='asx group parameter')

    return parser.parse_args(pargs)


if __name__ == '__main__':
    runstrat()

hbf

@backtrader Thank you for that! Feeling stupid for not realising there was a _debug parameter.

It appears that it was an issue with the order size being below the 20000 IdealPro minimum, resulting in a 399 error code. After amending the order size to meet the minimum criteria, the code which was previously added can be removed:

        if order.status == order.Completed:
            return

hbf

I implemented a live version of the 'Multi Example' using IB.

I had to add the following to the notify_order function due receiving a ValueError (Something to do with indexing an order that didn't exist in the if not order.alive(): statement):

        if order.status == order.Completed:
            return

It appears that whenever an order is submitted to the broker, the order is initially rejected before being accepted and completed.

962,2018-12-11T23:52:30,GBP.AUD-CASH-IDEALPRO,1.73331,1.73343,1.73330,1.73342,0.00000
2018-12-11T23:52:30 GBP.AUD-CASH-IDEALPRO Position 0
2018-12-11T23:52:30 GBP.AUD-CASH-IDEALPRO Buy 3
2018-12-11T23:53:00 EUR.USD-CASH-IDEALPRO Order 1 Status Rejected
-- No longer alive main Ref
2018-12-11T23:53:00 GBP.USD-CASH-IDEALPRO Order 2 Status Rejected
-- No longer alive main Ref
2018-12-11T23:53:00 GBP.AUD-CASH-IDEALPRO Order 3 Status Rejected
-- No longer alive main Ref
2018-12-11T23:53:00 EUR.USD-CASH-IDEALPRO Order 1 Status Accepted
2018-12-11T23:53:00 GBP.USD-CASH-IDEALPRO Order 2 Status Accepted
2018-12-11T23:53:00 GBP.AUD-CASH-IDEALPRO Order 3 Status Accepted
2018-12-11T23:53:00 EUR.USD-CASH-IDEALPRO Order 1 Status Completed
2018-12-11T23:53:00 GBP.USD-CASH-IDEALPRO Order 2 Status Completed
2018-12-11T23:53:00 GBP.AUD-CASH-IDEALPRO Order 3 Status Completed

Although this issue is not affecting performance yet, I was wondering if anyone had an insight as to what was causing it?

I assume it is the code modification I added above; however, without that modification I am unsure how to manage multiple orders.

from __future__ import (absolute_import, division, print_function,
                        unicode_literals)


import argparse
import datetime
import math

import backtrader as bt

class TestStrat(bt.Strategy):

    def notify_order(self, order):
        if order.status == order.Submitted:
            return

        dt, dn = self.data.datetime.datetime(0).isoformat(), order.data._name
        print('{} {} Order {} Status {}'.format(
            dt, dn, order.ref, order.getstatusname())
        )

        if order.status == order.Completed:
            return

        whichord = ['main', 'stop', 'limit', 'close']
        if not order.alive():  # not alive - nullify
            dorders = self.o[order.data]
            idx = dorders.index(order)
            dorders[idx] = None
            print('-- No longer alive {} Ref'.format(whichord[idx]))
            if all(x is None for x in dorders):
                dorders[:] = []  # empty list - New orders allowed

    def notify_trade(self, trade):
        dt, dn = self.data.datetime.datetime(0).isoformat(), trade.data._name
        if trade.isclosed:
            print('{} {} Gross Profit {} Net Profit {}' \
            .format(dt, dn, round(trade.pnl,2), round(trade.pnlcomm,2)))

    def __init__(self):
        self.o = dict()  # orders per data (main, stop, limit, manual-close)
        self.holding = dict()  # holding periods per data

    def logdata(self, d):
        txt = []
        txt.append('{}'.format(len(self)))
        txt.append('{}'.format(d.datetime.datetime(0).isoformat()))
        txt.append('{}'.format(d._name))
        txt.append('{:.5f}'.format(d.open[0]))
        txt.append('{:.5f}'.format(d.high[0]))
        txt.append('{:.5f}'.format(d.low[0]))
        txt.append('{:.5f}'.format(d.close[0]))
        txt.append('{:.5f}'.format(d.volume[0]))
        print(','.join(txt))

    data_live = False

    def notify_data(self, data, status, *args, **kwargs):
        print('*' * 5, data._name ,'DATA NOTIF:', data._getstatusname(status),
              *args)
        if status == data.LIVE:
            self.data_live = True

    def next(self):
        for i, d in enumerate(self.datas):

            self.logdata(d)

            if not self.data_live:
                return

            dt, dn = self.data.datetime.datetime(0).isoformat(), d._name
            pos = self.getposition(d).size
            print('{} {} Position {}'.format(dt, dn, pos))

            if not pos and not self.o.get(d, None):  # no market / no orders

                if (d.close[0] < d.close[-1]):
                    self.o[d] = [self.buy(data=d)]
                    print('{} {} Buy {}'.format(dt, dn, self.o[d][0].ref))

                elif (d.close[0] > d.close[-1]):
                    self.o[d] = [self.buy(data=d)]
                    print('{} {} Buy {}'.format(dt, dn, self.o[d][0].ref))

                self.holding[d] = 0

            elif pos:

                self.holding[d] += 1

                if self.holding[d] >= 2:
                    o = self.close(data=d)
                    self.o[d].append(o) # manual order to list of orders
                    print('{} {} Manual Close {}'.format(dt, dn, o.ref))


def runstrat(args=None):

    args = parse_args(args)

    cerebro = bt.Cerebro()

    # Data feed kwargs
    kwargs = dict()

    # Store
    store = bt.stores.IBStore(port=7497, host='127.0.0.1')

    # Data feeds
    securities = ['EUR.USD-CASH-IDEALPRO','GBP.USD-CASH-IDEALPRO',
                  'GBP.AUD-CASH-IDEALPRO']

    for security in securities:
        data = store.getdata(dataname=security, timeframe=bt.TimeFrame.Ticks)
        cerebro.resampledata(data, timeframe=args.timeframe,
                             compression=args.compression, name=security)

    # Broker
    cerebro.broker = store.getbroker()

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

    # Execute
    cerebro.run(**eval('dict(' + args.cerebro + ')'))


def parse_args(pargs=None):
    parser = argparse.ArgumentParser(
        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
        description=(
            'Multiple Values'
        )
    )

    parser.add_argument('--cerebro', required=False, default='',
                        metavar='kwargs', help='kwargs in key=value format')

    parser.add_argument('--broker', required=False, default='',
                        metavar='kwargs', help='kwargs in key=value format')

    parser.add_argument('--sizer', required=False, default='',
                        metavar='kwargs', help='kwargs in key=value format')

    parser.add_argument('--strat', required=False, default='',
                        metavar='kwargs', help='kwargs in key=value format')

    parser.add_argument('--timeframe', required=False,
                        default=bt.TimeFrame.Seconds, action='store',
                        help='datafeed timeframe parameter')

    parser.add_argument('--compression', required=False,
                        default=30, action='store',
                        help='datafeed compression parameter')

    return parser.parse_args(pargs)


if __name__ == '__main__':
    runstrat()

Thank you for your help.

hbf

@backtrader @RandyT @Systematica

I'm trying to implement this with the following live code:

from __future__ import (absolute_import, division, print_function,
                        unicode_literals)


import datetime

import backtrader as bt

class St(bt.Strategy):

    def __init__(self):
        self.lendata1 = 0

    data_live = False

    def notify_data(self, data, status, *args, **kwargs):
        print('*' * 5, data._name ,'DATA NOTIF:', data._getstatusname(status),
              *args)
        if status == data.LIVE:
            self.data_live = True

    def next(self):
        txt = list()
        txt.append('Data0')
        txt.append('%04d' % len(self.data0))
        dtfmt = '%Y-%m-%dT%H:%M:%S.%f'
        txt.append('{}'.format(self.data.datetime[0]))
        txt.append('%s' % self.data.datetime.datetime(0).strftime(dtfmt))
        txt.append('{}'.format(self.data.open[0]))
        txt.append('{}'.format(self.data.high[0]))
        txt.append('{}'.format(self.data.low[0]))
        txt.append('{}'.format(self.data.close[0]))
        txt.append('{}'.format(self.data.volume[0]))
        txt.append('{}'.format(self.data.openinterest[0]))
        print(', '.join(txt))

        if len(self.datas) > 1 and len(self.data1):
            txt = list()
            txt.append('Data1')
            txt.append('%04d' % len(self.data1))
            dtfmt = '%Y-%m-%dT%H:%M:%S.%f'
            txt.append('{}'.format(self.data1.datetime[0]))
            txt.append('%s' % self.data1.datetime.datetime(0).strftime(dtfmt))
            txt.append('{}'.format(self.data1.open[0]))
            txt.append('{}'.format(self.data1.high[0]))
            txt.append('{}'.format(self.data1.low[0]))
            txt.append('{}'.format(self.data1.close[0]))
            txt.append('{}'.format(self.data1.volume[0]))
            txt.append('{}'.format(self.data1.openinterest[0]))
            print(', '.join(txt))

        if len(self.data1) > self.lendata1:
            print(len(self.data1))
            self.lendata1 += 1
            print(self.lendata1)

def runstrat(args=None):

    cerebro = bt.Cerebro()

    # Store
    store = bt.stores.IBStore(port=7497, host='127.0.0.1')

    # Data feed
    data = store.getdata(dataname='AUD.CAD-CASH-IDEALPRO')
    data1 = store.getdata(dataname='AUD.CAD-CASH-IDEALPRO')
    tf0n = str('1m')
    tf1n = str('5m')
    cerebro.resampledata(data, timeframe=bt.TimeFrame.Minutes,
                         compression=1, name=tf0n)
    cerebro.resampledata(data1, timeframe=bt.TimeFrame.Minutes,
                         compression=5, name=tf1n)
    # Broker
    cerebro.broker = store.getbroker()

    # Strategy
    cerebro.addstrategy(St)

    # Execute
    cerebro.run()

if __name__ == '__main__':
    runstrat()

The problem I'm having is that even though I have initiated lendata1 on init, it doesn't seem to be updating on next. The line printed 1 should be 1180, 2 should be 1181 and 282 should be 1197.

Server Version: 76
TWS Time at connection:20181210 13:50:51 AEST
***** 1m DATA NOTIF: DELAYED
***** 5m DATA NOTIF: DELAYED
1340,2018-12-10T01:34:00,1m,0.95982,0.95984,0.95971,0.95975,-1.00000
1180
1
1341,2018-12-10T01:35:00,1m,0.95975,0.95983,0.95963,0.95964,-1.00000
1181
2
...
***** 1m DATA NOTIF: LIVE
***** 5m DATA NOTIF: LIVE
Data0, 0282, 737038.122222, 2018-12-09T21:56:00.000000, 0.9598, 0.95981, 0.95979, 0.95979, 0.0, 0.0
Data1, 1197, 737038.121528, 2018-12-09T21:55:00.000000, 0.95981, 0.95982, 0.95978, 0.95981, -1.0, 0.0
1197
282

I assume that it is because of the backfill. I was wondering if you had any suggestions? Thank you.

Weirdly, it has been working when testing on different timeframes. The following code modification stores the correct values for self.lendata1

    # Data feed
    data = store.getdata(dataname='AUD.CAD-CASH-IDEALPRO')
    data1 = store.getdata(dataname='AUD.CAD-CASH-IDEALPRO')
    tf0n = str('5m')
    tf1n = str('1h')
    cerebro.resampledata(data, timeframe=bt.TimeFrame.Minutes,
                         compression=5, name=tf0n)
    cerebro.resampledata(data1, timeframe=bt.TimeFrame.Minutes,
                         compression=60, name=tf1n)

UPDATE: I have used the following:

def nextstart(self):
     self.lendata1 = len(self.data1)

Updated code:

from __future__ import (absolute_import, division, print_function,
                        unicode_literals)


import datetime

import backtrader as bt

class St(bt.Strategy):

    def __init__(self):
        self.lendata1 = 0

    data_live = False

    def notify_data(self, data, status, *args, **kwargs):
        print('*' * 5, data._name ,'DATA NOTIF:', data._getstatusname(status),
              *args)
        if status == data.LIVE:
            self.data_live = True

    def nextstart(self):
        self.lendata1 = len(self.data1)

    def next(self):
        txt = list()
        txt.append('Data0')
        txt.append('{}'.format(len(self.data0)))
        txt.append('{}'.format(self.data.datetime.datetime(0).isoformat()))
        txt.append('{}'.format(self.data.open[0]))
        txt.append('{}'.format(self.data.high[0]))
        txt.append('{}'.format(self.data.low[0]))
        txt.append('{}'.format(self.data.close[0]))
        txt.append('{}'.format(self.data.volume[0]))
        txt.append('{}'.format(self.data.openinterest[0]))
        print(', '.join(txt))

        if len(self.datas) > 1 and len(self.data1):
            txt = list()
            txt.append('Data1')
            txt.append('{}'.format(len(self.data1)))
            txt.append('{}'.format(self.data1.datetime.datetime(0).isoformat()))
            txt.append('{}'.format(self.data1.open[0]))
            txt.append('{}'.format(self.data1.high[0]))
            txt.append('{}'.format(self.data1.low[0]))
            txt.append('{}'.format(self.data1.close[0]))
            txt.append('{}'.format(self.data1.volume[0]))
            txt.append('{}'.format(self.data1.openinterest[0]))
            print(', '.join(txt))

        if len(self.data1) > self.lendata1:
            print(len(self.data1))
            self.lendata1 += 1
            print(self.lendata1)
            print('new higher tf bar')

def runstrat(args=None):

    cerebro = bt.Cerebro()

    # Store
    store = bt.stores.IBStore(port=7497, host='127.0.0.1')

    # Data feed
    data = store.getdata(dataname='AUD.CAD-CASH-IDEALPRO',
                         timeframe=bt.TimeFrame.Ticks)
    
    tf0n = str('30s')
    tf1n = str('2m')

    cerebro.resampledata(data, timeframe=bt.TimeFrame.Seconds,
                         compression=30, name=tf0n)

    cerebro.resampledata(data, timeframe=bt.TimeFrame.Minutes,
                         compression=2, name=tf1n)

    # Broker
    cerebro.broker = store.getbroker()

    # Strategy
    cerebro.addstrategy(St)

    # Execute
    cerebro.run()

if __name__ == '__main__':
    runstrat()

hbf

Changed the approach.

Now using Windows Subsystem for Linux.

Have created the following shell script if anyone considers doing the same thing.

#!/bin/sh
codelist='EUR.USD-CASH-IDEALPRO GBP.USD-CASH-IDEALPRO'

for code in $codelist
do
  if [ $(pgrep -f 'python ibtest.py --data '$code) \
  > /dev/null ]
  then
    echo $code ' strategy already running'
  else
    rm output_$code.txt &
    nohup python ibtest.py --data $code \
    > output_$code.txt &
  fi
done

hbf

@ab_trader @backtrader Thank you both for your responses.

A little bit more info:

Currently, the system is being tested on an IB paper account which is subscribed to data feeds. The idea behind opening multiple cmd windows and running the strategy for each security was so that the constant live feed that is output by the logdata, notify_data, notify_order, notify_trade etc. functions could be interpreted simultaneously through the command windows.

For backtesting across multiple securities, I have used a for loop like @backtrader has suggested and have output analysers to a csv document. My confusion lies in the connection to the broker and analysing the live data feed. Does this change your answer? If not, how can the output be interpreted whilst the strategy is running?

Thank you both for your suggestions. I will look into the Windows Subsystem for Linux and Cygwin. I guess my priorities have been to get a system up and running ASAP, without consideration of best practices. These will be implemented as I continue to learn.

hbf

@ab_trader The problem with using the standard approach is that the universe is large (e.g. 200 stocks) and variable (e.g. may only want to run on 50 stocks at a time)

hbf

@hbf

Posts made by hbf