@run-out said in How to use 5minutes BOLL and 10 minute BOLL together?:

A few things to help you on your way.

You don't need to add data with resample. Resample will add the date automatically.

Also, you use the variable self.lines.top twice. Finally, I would avoid using the .lines. Not sure if there's an impact here but lines are an important word inside backtrader.

I've rewritten your code a bit to help you out.

import backtrader as bt

class Strategy(bt.Strategy):

    params = (("bb_period", 22),)

    def __init__(self):
        self.bb = bt.indicators.BollingerBands(self.datas[0], period=self.p.bb_period)
        self.bb5 = bt.indicators.BollingerBands(self.datas[1], period=self.p.bb_period)
        self.bb30 = bt.indicators.BollingerBands(self.datas[2], period=self.p.bb_period)

    def next(self):
        print(
            "OHLCV",
            bt.num2date(self.data.datetime[0]),
            self.datas[0].close[0],
            self.datas[1].close[0],
            self.datas[2].close[0],
        )
        print(
            "Bollinger Bands\n",
            "minute", self.bb.top[0], self.bb[0], self.bb.bot[0], '\n',
            "5 min", self.bb5.top[0], self.bb5[0], self.bb5.bot[0], '\n',
            "30 min", self.bb30.top[0], self.bb30[0], self.bb30.bot[0], '\n',
        )

if __name__ == "__main__":

    cerebro = bt.Cerebro()

    data = bt.feeds.GenericCSVData(
        dataname="data/dev.csv",
        dtformat=("%Y-%m-%d %H:%M:%S"),
        timeframe=bt.TimeFrame.Minutes,
        compression=1,
        date=0,
        high=1,
        low=2,
        open=3,
        close=4,
        volume=6,
    )

    cerebro.adddata(data)
    cerebro.resampledata(data, timeframe=bt.TimeFrame.Minutes, compression=5)
    cerebro.resampledata(data, timeframe=bt.TimeFrame.Minutes, compression=30)

    cerebro.addstrategy(Strategy)

    # Execute
    cerebro.run()

cool, works charm, thanks a lot

@run-out said in it seems dead loop if just simple cross strategy:

@goldcar said in it seems dead loop if just simple cross strategy:

if self.position.size == 0:
         if self.k[0] > self.d[0] :
                self.order = self.buy()
         else:
               self.order = self.sell()

elif self.position.size < 0:
         if self.k[0] > self.d[0] :
             self.order = self.close()

elif self.position.size > 0:
         if self.k[0] < self.d[0] :
            self.order = self.close()

You will only execute one of these conditionals per loop. This means that you cannot close and go short for example, in the same loop, using this code. You should also note that the buys and sells will not happen instantly. So to correct you may wish to try the following:

if self.k[0] > self.d[0]:
    if self.position:
        self.close()
    self.order = self.buy()

elif self.k[0] < self.d[0]:
    if self.position:
        self.close()
    self.order = self.sell()

oh...I see. thanks a lot

I modify the IBTEST sample as below:

class SmaCross(bt.Strategy):

    def __init__(self):
        self.beeapi = self.p.store.main_ctpbee_api
        self.beeapi.strategy = self
    def next(self):
        print('------------------------------------------ next start') #nothing print out here.
    def on_tick(self, tick) -> None:
        print(tick.datetime, tick.last_price) #nothing print out
        print("--------------------------------------------------------on tick in cat")
        pass

if __name__ == '__main__':
    with open('./params.json', 'r') as f:
        ctp_setting = json.load(f)
    cerebro = bt.Cerebro(live=True)
    store = CTPStore(ctp_setting, debug=True)
    data0_name = 'ag2212.SHFE'
    compression = 2
    data0 = store.getdata(dataname=data0_name,
                          timeframe=bt.TimeFrame.Ticks,
                          )
    cerebro.resampledata(data0,
                         timeframe=bt.TimeFrame.Seconds,
                         compression=compression
                         )

    cerebro.addstrategy(SmaCross, store=store)
    cerebro.run()

and some of the store part as below:

class MyCtpbeeApi(CtpbeeApi):
    def __init__(self, name, md_queue=None):
        super().__init__(name)
        self.md_queue = md_queue 
        self.is_position_ok = False
        self.is_account_ok = False
    def on_tick(self, tick: TickData) -> None:
        print(tick.datetime, tick)  #it prints out the incoming datas
        pass
    def on_bar(self, bar: BarData) -> None:
        print("on bar coming") # it works here
        self.md_queue[bar.local_symbol].put(bar)
    def on_init(self, init):
        pass

class MetaSingleton(MetaParams):
    """Metaclass to make a metaclassed class a singleton"""

    def __init__(cls, name, bases, dct):
        super(MetaSingleton, cls).__init__(name, bases, dct)
        cls._singleton = None

    def __call__(cls, *args, **kwargs):
        if cls._singleton is None:
            cls._singleton = super(MetaSingleton, cls).__call__(*args, **kwargs)
        return cls._singleton


class CTPStore(with_metaclass(MetaSingleton, object)):
    BrokerCls = None  #broker class will auto register
    DataCls = None    #data class will auto register
    @classmethod
    def getdata(cls, *args, **kwargs):
        """Returns `DataCls` with args, kwargs"""
        return cls.DataCls(*args, **kwargs)

    @classmethod
    def getbroker(cls, *args, **kwargs):
        """Returns broker with *args, **kwargs from registered `BrokerCls`"""
        return cls.BrokerCls(*args, **kwargs)

    def __init__(self, ctp_setting, *args, **kwargs):
        super(CTPStore, self).__init__()
        self.ctp_setting = ctp_setting
        self._cash = 0.0
        self._value = 0.0
        self.q_feed_qlive = dict()
        self.main_ctpbee_api = MyCtpbeeApi("main_ctpbee_api", md_queue=self.q_feed_qlive)
        self.app = CtpBee("ctpstore", __name__, refresh=True)
        self.app.config.from_mapping(ctp_setting)
        self.app.add_extension(self.main_ctpbee_api)
        self.app.start(log_output=True)
        while True:
            sleep(1)
            if self.main_ctpbee_api.is_account_ok:
                break
        print('positions===>', self.main_ctpbee_api.center.positions)
        print('account===>', self.main_ctpbee_api.center.account)

Both has "on tick", but only the one in store class can print out incoming tick datas. in stragecy class ,it doesn't print out the tick data. And, it store class's ON_BAR, it print out bar data no problem, but there is no action in "NEXT" of stragecy class.

I am new in Python, dont know how to fix it. any help? appreciated!

I righ click the "def next(self)"--"Goto implementation", it is nothing.

I am trying to make strategy then run NEXT every tick received. but it seems nothing changes.
anyone here can help? code is below:

if __name__ == '__main__':
    with open('./params.json', 'r') as f:
        ctp_setting = json.load(f)
    cerebro = bt.Cerebro(live=True)
    store = CTPStore(ctp_setting, debug=True)
    data0_name = 'ag2212.SHFE'
    tz = pytz.timezone('Asia/Shanghai')
    data0 = store.getdata(dataname=data0_name,
                          timeframe=bt.TimeFrame.Ticks,
                          backfill_from=None,
                          qcheck=5,
                          sessionstart=time(21, 00, 00),
                          sessionend=time(15, 00, 00),
                          name=data0_name + '_tick',
                          tzinput=tz,
                          tz=tz,
                          compression=1,
                          rtbar=True,
                          )
    cerebro.resampledata(data0, timeframe=bt.TimeFrame.Seconds, compression=5,
                         name=data0_name + '_10s')
    cerebro.addstrategy(SmaCross, store=store)
    cerebro.run(is_realtime=True, tz=tz)

It still goes into minute whatever I change the timeframe. Any idea? Thanks

error not in my code. seems from framework.

for example:
self.boll_up = bt.indicators.BollingerBands(self.data0, period=26).top()

backfill is 1000.

so it reaches 1000 bars at beginning.
as problem keep running, I find it increases up 1001...1002...1003....
if it is a minute bar, one day will generate thousands bar in memory? what happen the program running on cloud without humen reset? will it cause server down?

is there a way clear the old bars in memory?

@run-out thanks, got it.

There are some indicators in "init", some of them is 120minutes period.
so when I run the living trading, it will take a long time to enter the NEXT.
Is there a better faster way to fill the indicators period

My broker provides the following connection parameters:

username,password
TCP with port for trading connection
TCP with port for marketing connection
appid
authorize code.
where to config it with those parameters?

@run-out said in it seems dead loop if just simple cross strategy:

@goldcar said in it seems dead loop if just simple cross strategy:

if self.position.size == 0:
         if self.k[0] > self.d[0] :
                self.order = self.buy()
         else:
               self.order = self.sell()

elif self.position.size < 0:
         if self.k[0] > self.d[0] :
             self.order = self.close()

elif self.position.size > 0:
         if self.k[0] < self.d[0] :
            self.order = self.close()

You will only execute one of these conditionals per loop. This means that you cannot close and go short for example, in the same loop, using this code. You should also note that the buys and sells will not happen instantly. So to correct you may wish to try the following:

if self.k[0] > self.d[0]:
    if self.position:
        self.close()
    self.order = self.buy()

elif self.k[0] < self.d[0]:
    if self.position:
        self.close()
    self.order = self.sell()

oh...I see. thanks a lot

In my market, it can send short order not just close the long order. So I make a simple strategy when KDJ's K cross D then place long order, and close short-order at same time(if it has), if K lower then D, then place short order and close long order at same time.

    if self.position.size == 0:
             if self.k[0] > self.d[0] :
                    self.order = self.buy()
             else:
                   self.order = self.sell()

    elif self.position.size < 0:
             if self.k[0] > self.d[0] :
                 self.order = self.close()

    elif self.position.size > 0:
             if self.k[0] < self.d[0] :
                self.order = self.close()

It seems mess . It place orders ramdom, seems the previous order not finished then place new order, or Closing order not finish then come up next order...not sure.. just like dead loop till funds goes down to reject new orders.

Any suggestion for this?