I finished the polling, I am using sleep in a thread, the time diff I calculate by start of next period and current time.

Thanks again for your help @backtrader

   def poll_thread(self):
       t = threading.Thread(target=self._t_poll)
       t.daemon = True
       t.start()

   def _t_poll(self):
       dtstart = self._getstarttime(self._timeframe, self._compression, offset=2)
       qcandles = queue.Queue()
       while True:
           dtcurr = self._getstarttime(self._timeframe, self._compression)
           # request candles in live instead of stream
           if dtcurr > dtstart:
               if len(self) > 1:
                   # len == 1 ... forwarded for the 1st time
                   dtbegin = self.datetime.datetime(-1)
               elif self.fromdate > float('-inf'):
                   dtbegin = num2date(self.fromdate)
               else:  # 1st bar and no begin set
                   dtbegin = dtstart
               self.qlive = self.o.candles(
                   self.p.dataname, dtbegin, None,
                   self._timeframe, self._compression,
                   candleFormat=self._candleFormat,
                   onlyComplete=True,
                   includeFirst=False)
               dtstart = dtbegin
               # sleep until next call
               dtnow = datetime.utcnow()
               dtnext = self._getstarttime(self._timeframe, self._compression, dt=dtnow, offset=-1)
               dtdiff = dtnext - dtnow
               tmout = (dtdiff.days*24*60*60) + dtdiff.seconds + 1
               if tmout <= 0: tmout = 5
               _time.sleep(tmout)

   def _getstarttime(self, timeframe, compression, dt = None, offset = 0):
       '''This method will return the start of the period based on current 
       time (or provided time). It is using UTC 22:00 (5:00 pm New York) 
       as the start of the day.'''
       if dt == None:
           dt = datetime.utcnow()
       if timeframe == TimeFrame.Seconds:
           dt = dt.replace(second=(dt.second//compression)*compression, microsecond=0)
           if offset:
               dt = dt - timedelta(seconds=compression*offset)
       elif timeframe == TimeFrame.Minutes:
           if compression >= 60:
               hours = 0
               minutes = 0
               # get start of day
               dtstart = self._getstarttime(TimeFrame.Days, 1, dt)
               #diff start of day with current time to get seconds since start of day
               dtdiff = dt - dtstart
               hours = dtdiff.seconds//((60*60)*(compression//60))
               minutes = compression % 60
               dt = dtstart + timedelta(hours=hours, minutes=minutes)
           else:
               dt = dt.replace(minute=(dt.minute//compression)*compression, second=0, microsecond=0)
           if offset:
               dt = dt - timedelta(minutes=compression*offset)
       elif timeframe == TimeFrame.Days:
           # start of day is UTC 22 (5pm new york)
           if dt.hour < 22:
               dt = dt - timedelta(days=1)
           if offset:
               dt = dt - timedelta(days=offset)
           dt = dt.replace(hour=22, minute=0, second=0, microsecond=0)
       elif timeframe == TimeFrame.Weeks:
           if dt.weekday() != 6:
               # sunday is start of week at 5pm new york
               dt = dt - timedelta(days=dt.weekday() + 1)
           if offset:
               dt = dt - timedelta(days=offset * 7)
           dt = dt.replace(hour=22, minute=0, second=0, microsecond=0)
       elif timeframe == TimeFrame.Months:
           if offset:
               dt= dt - timedelta(days=(min(28+dt.day, 31)))
           # last day of month
           last_day_of_month = dt.replace(day=28) + timedelta(days=4)
           last_day_of_month = last_day_of_month - timedelta(days=last_day_of_month.day)
           last_day_of_month = last_day_of_month.day
           # start of month (1 at 0, 22 last day of prev month)
           if dt.day < last_day_of_month:
               dt = dt - timedelta(days=dt.day)
           dt = dt.replace(hour=22, minute=0, second=0, microsecond=0)
       return dt

This method will return the start of the period based on current time (or provided time). It is using UTC 22:00 (5:00 pm New York) as the start of the day.

Fixed version:

   def _getstarttime(self, timeframe, compression, dt = None, offset = 0):
       if dt == None:
           dt = datetime.utcnow()
       if timeframe == TimeFrame.Seconds:
           dt = dt.replace(second=dt.second//compression, microsecond=0)
           if offset > 0:
               dt = dt - timedelta(seconds=compression*offset)
       elif timeframe == TimeFrame.Minutes:
           if compression >= 60:
               hours = 0
               minutes = 0
               # get start of day
               dtstart = self._getstarttime(TimeFrame.Days, 1, dt)
               #diff start of day with current time to get seconds since start of day
               dtdiff = dt - dtstart
               hours = dtdiff.seconds//((60*60)*(compression//60))
               minutes = compression % 60
               dt = dtstart + timedelta(hours=hours, minutes=minutes)
           else:
               dt = dt.replace(minute=compression, second=0, microsecond=0)
           if offset > 0:
               dt = dt - timedelta(minutes=compression*offset)
       elif timeframe == TimeFrame.Days:
           # start of day is UTC 22 (5pm new york)
           if dt.hour < 22:
               dt = dt - timedelta(days=1)
           if offset:
               dt = dt - timedelta(days=offset)
           dt = dt.replace(hour=22, minute=0, second=0, microsecond=0)
       elif timeframe == TimeFrame.Weeks:
           if dt.weekday() != 6:
               # sunday is start of week at 5pm new york
               dt = dt - timedelta(days=dt.weekday() + 1)
           if offset:
               dt = dt - timedelta(days=offset * 7)
           dt = dt.replace(hour=22, minute=0, second=0, microsecond=0)
       elif timeframe == TimeFrame.Months:
           if offset > 0:
               dt= dt - timedelta(days=(min(28+dt.day, 31)))
           # last day of month
           last_day_of_month = dt.replace(day=28) + timedelta(days=4)
           last_day_of_month = last_day_of_month - timedelta(days=last_day_of_month.day)
           last_day_of_month = last_day_of_month.day
           # start of month (1 at 0, 22 last day of prev month)
           if dt.day < last_day_of_month:
               dt = dt - timedelta(days=dt.day)
           dt = dt.replace(hour=22, minute=0, second=0, microsecond=0)
       return dt

I added a method to calculate the start time of the period.

It's for oanda, so i set the day, week and month to UTC 22:00 as the start time. Maybe someone will need this code, so here is how I do it.

def _getstarttime(self, timeframe, compression, dt = None, offset = 0):
       if dt == None:
           dt = datetime.utcnow()
       if timeframe == TimeFrame.Seconds:
           dt = dt.replace(second=dt.second//compression, microsecond=0)
           if offset > 0:
               dt = dt - timedelta(seconds=compression*offset)
       elif timeframe == TimeFrame.Minutes:
           hour = 0
           if compression >= 60:
               hour = compression//60
           minute = compression % 60
           dt = dt - timedelta(hours=hour, minutes=minute)
           dt = dt.replace(minute=dt.minute//minute, second=0, microsecond=0)
           if offset > 0:
               dt = dt - timedelta(minutes=compression*offset)
       elif timeframe == TimeFrame.Days:
           # start of day is UTC 22 (5pm new york)
           if dtnow.hour < 22:
               dt = dt - timedelta(days=1)
           if offset:
               dt = dt - timedelta(days=offset)
           dt = dt.replace(hour=22, minute=0, second=0, microsecond=0)
       elif timeframe == TimeFrame.Weeks:
           if dt.weekday() != 6:
               # sunday is start of week at 5pm new york
               dt = dt - timedelta(days=dt.weekday() + 1)
           if offset:
               dt = dt - timedelta(days=offset * 7)
           dt = dt.replace(hour=22, minute=0, second=0, microsecond=0)
       elif timeframe == TimeFrame.Months:
           if offset > 0:
               dt.replace(month=dt.month - offset)
           # last day of month
           last_day_of_month = dt.replace(day=28) + timedelta(days=4)
           last_day_of_month = last_day_of_month - timedelta(days=last_day_of_month.day)
           last_day_of_month = last_day_of_month.day
           # start of month (1 at 0, 22 last day of prev month)
           if dt.day < last_day_of_month:
               dt = dt - timedelta(days=dt.day)
           dt = dt.replace(hour=22, minute=0, second=0, microsecond=0)
       return dt

Edit:

This method above will not have correct start times for intervals > 60 minutes for intraday. Will post an updated version, which fixes that issue.

Maybe an example of data I need would explain it a bit better:

Assume:
Now: 4:13
Period: 5 Min

Required time / data:
Previous complete period start: 4:05
Current period start: 4:10

I would then use previous period time for start time,
current period time stored, to check if it is different from current period start of current time (at 4:16 it would be 4:15 as start, so I would fetch new data if not already done and current stored period start is 4:15)

I hope that is more understandable

Hi

in the backtrader oanda v20 store, I added a method to use poll instead of stream. This provides volume in live data (which is delayed by the interval). I poll for data based on qcheck, but this will do a lot of unnecessary requests.

How would I best check if interval is about to end or how to minimize the amount of requests when no new data is expected?

For example when the timeframe is 15 Minutes, the feed should poll shortly after the timeframe is complete (0:00, 0:15, 0:30, 0:45 ... + a few microseconds)

Is there some functionality in backtrader to give me that info in a feed?

The oanda v20 store is located here:
https://github.com/ftomassetti/backtrader-oandav20

The last commit added the candles support

Thanks in advance for any ideas or help :)

Thanks a lot for that fix

for low and high, you can access it with:

                self.datas[0].low
                self.datas[0].high

When rightedge=False, Backtrader will output all data immediately. The issue is due to a wrong assumption of the end of the current resampling.

The end point is added only if rightedge = True but should also when rightedge = False

Line 384,385 - resamplerfilter.py

        # If rightedge (end of boundary is activated) add it unless recursing
        point += self.p.rightedge

instead it should always add 1, but the correct timestamp should be set differently?

point += 1

You can do it this way:

# -*- coding: utf-8 -*-

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

# Import the backtrader platform
import backtrader as bt
import backtrader.indicators as btind
from backtrader.observer import Observer as btobserver

import datetime
import time

'''
TD Sequential-Style indicator

// S = Sell Signal
// B = Buy Signal
// A = Sell (above bar) or Buy (below bar) Signal that is 'not ideal' - meaning the signal bar's or the previous bar's high or low is not higer or lower than one of the previous 2 bars.
// - This could indicate that waiting another bar will deliver a 'true' signal. (Useful at the beginning of the trend reversal signal, not so much at the end)
//
// Indicator and Rules based on indicator as seen on CoinSheet.org


    Ein TD Sequential Buy Setup ist erfüllt, wenn 9 aufeinanderfolgende Bars tiefer Schliessen als 4 Bars zuvor. Für den Sell ist es umgekehrt, dort müssen 9 aufeinanderfolgende Bars höher Schliessen als 4 Bars zuvor.

    Das Ziel der Zählung ist es, mögliche Wendepunkte anzuzeigen und somit Low Risk Entrys zu finden. Falls die Bedingungen nicht bis zum 9er Count erfüllt wird, ist das Setup gecancelt. Sobald ein TD Setup erfüllt ist, würde normalerweise die Countdown resp. Intersection-Phase beginnen. Beim Countdown werden danach 13 Bars die einen tiefern Close haben, als das Low des zwei Bars zurückliegenden Stabes. Die Countdown Bars müssen jedoch nicht aufeinanderfolgen, die Zählung läuft weiter bis zu Bar 13, sofern nicht das Hoch des vorangehenden TD Setups (bei einem Buy Setup...sonst natürlich das Tief bei einem Sell) überschritten wird.

    Das ist jetzt wirklich nur ein ganz grober Überblick der Standartparameter.???

    Beim angehängten Indi handelt es sich übrigens um den TD Combo und nicht den TD Sequential. Der Unterschied zwischen den beiden liegt einfach gesagt darin, dass die Countdown Zählung beim erreichen eines kompletten TD Setups, die Countdownzählung zürückrechnet und somit schon beim ersten Bar des Setups beginnen kann, anstatt erst nach der Beendigung des Setups.:P

    Grob gesagt kann beim erfüllen eines Setups mit einem kleinen Wendepunkt gerechnet werden und beim erfüllen eines Countdowns ein grosser Wendepunkt.
    
    Entry:
    There are three methods of entry:
    (a) Enter on the close of the day on which the countdown is completed;
    (b) Long Trades: Enter on the close if Close[i] > Close[i - 4];
        Short Trades: Enter on the close if Close[i] < Close[i - 4];
    (c) Long Trades: Enter on the close if Close[i] > High[i - 2];
        Short Trades: Enter on the close if Close[i] < Low[i - 2]. Index: i ~ Current Bar. In this test we apply the 2nd method.
    
    Exit:
    Pattern Exit: The current position is liquidated once the new setup is complete and price fails to exceed the furthest price recorded by the recent inactive setup.
    Stop Loss Exit: 
    Long Trades: The difference between the close at the entry bar and the low of the lowest day of the pattern is subtracted from the low of the lowest day. Short Trades: The difference between the high of the highest day of the pattern and the close at the entry bar is added to the high of the highest day.                
    Note: In order to activate a stop loss, the close must exceed the calculated levels.

'''

class strategy(bt.Strategy):
    params = dict(
      candles_past_to_compare = 4,
      stoploss_dist = 0.0,
    )

    ''' Logging function for strategy '''
    def log(self, txt, dt=None):
        dt = dt or self.dataprimary.datetime.datetime(0)
        print('%s, %s' % (dt.isoformat(), txt))
    
    
    '''Initialization '''    
    def __init__(self):
        # Keep a reference to the primary data feed
        self.dataprimary = self.datas[0]
        # Keep a reference to the "close" line in the primary dataseries
        self.dataclose = self.dataprimary.close
        # Control vars
        self.live = True
        self.order = None

        self.bearishFlip = False
        self.bullishFlip = False

        self.tdsl = 0 # TD sequence long
        self.tdss = 0 # TD sequence short
        self.buySetup = False # TD buy setup 
        self.sellSetup = False # TD sell setup
        self.buyCountdown = 0 # TD buy countdown
        self.sellCountdown = 0 # TD sell countdown
        self.buyVal = 0 # buy value at intersection
        self.sellVal = 0 # sell value at intersection
        
        self.buySig = False
        self.idealBuySig = False
        self.sellSig = False
        self.idealSellSig = False

        print('-' * 80)
        print('Strategy Created')
        print('-' * 80)


    ''' Data notification '''
    def notify_data(self, data, status, *args, **kwargs):
        print('*' * 5, 'DATA NOTIF:', data._getstatusname(status), *args)
        if status == data.LIVE:
            self.live = True
        elif status == data.DELAYED:
            self.live = False


    ''' Store notification '''
    def notify_store(self, msg, *args, **kwargs):
        print('*' * 5, 'STORE NOTIF:', msg)
        

    ''' Order notification '''
    def notify_order(self, order):
        if order.status in [order.Completed, order.Cancelled, order.Rejected]:
            self.order = None
        print('-' * 50, 'ORDER BEGIN', datetime.datetime.now())
        print(order)
        print('-' * 50, 'ORDER END')


    ''' Trade notification '''
    def notify_trade(self, trade):
        print('-' * 50, 'TRADE BEGIN', datetime.datetime.now())
        print(trade)
        print('-' * 50, 'TRADE END')
        
        if not trade.isclosed:
            return

        self.log('OPERATION PROFIT, GROSS %.2f, NET %.2f' %
            (trade.pnl, trade.pnlcomm))

    ''' Next '''        
    def next(self):
        self.buySig = False
        self.sellSig = False
        self.idealBuySig = False
        self.idealSellSig = False
        
        # Calculate td sequential values if enough bars
        if len(self.dataclose) > self.p.candles_past_to_compare:
            
            # begin of sequence, bullish or bearish flip
            if self.dataclose[0] < self.dataclose[-self.p.candles_past_to_compare] and self.dataclose[-1] > self.dataclose[-(self.p.candles_past_to_compare + 1)]:
                self.bearishFlip = True
                self.bullishFlip = False
                self.tdsl = 0
                self.tdss = 0
                self.sellSetup = False
                self.sellCountdown = 0
            elif self.dataclose[0] > self.dataclose[-self.p.candles_past_to_compare] and self.dataclose[-1] < self.dataclose[-(self.p.candles_past_to_compare + 1)]:
                self.bullishFlip = True
                self.bearishFlip = False
                self.tdss = 0
                self.tdsl = 0
                self.buySetup = False
                self.buyCountdown = 0

            # sequence start
            if self.dataclose[0] < self.dataclose[-self.p.candles_past_to_compare] and self.bearishFlip:
                self.tdsl += 1
            elif self.dataclose[0] > self.dataclose[-self.p.candles_past_to_compare] and self.bullishFlip:
                self.tdss += 1
            
            # sequence intersection
            if self.tdsl == 9:
                self.buySig = (self.dataprimary.low[0] < self.dataprimary.low[-3] and self.dataprimary.low[0] < self.dataprimary.low[-2]) or (self.dataprimary.low[-1] < self.dataprimary.low[-2] and self.dataprimary.low[-1] < self.dataprimary.low[-3])
                self.bearishFlip = False
                self.tdsl = 0
                self.buySetup = True
                self.buyCountdown = 0
            elif self.tdss == 9:
                self.sellSig = (self.dataprimary.high[0] > self.dataprimary.high[-2] and self.dataprimary.high[0] > self.dataprimary.high[-3]) or (self.dataprimary.high[-1] > self.dataprimary.high[-3] and self.dataprimary.high[-1] > self.dataprimary.high[-2])
                self.bullishFlip = False
                self.tdss = 0
                self.sellSetup = True
                self.sellCountdown = 0
                
            # sequence countdown
            if self.buySetup:
                if self.dataprimary.close[0] <= self.dataprimary.low[-2]:
                    self.buyCountdown += 1
                if self.buyCountdown == 8:
                    self.buyVal = self.dataclose[0]
                elif self.buyCountdown == 13:
                    if self.dataprimary.low[0] <= self.buyVal:
                        self.idealBuySig = True
                    self.buySetup = False
                    self.buyCountdown = 0
                    
            elif self.sellSetup:
                if self.dataprimary.close[0] >= self.dataprimary.high[-2]:
                    self.sellCountdown += 1
                if self.sellCountdown == 8:
                    self.sellVal = self.dataclose[0]
                elif self.sellCountdown == 13:
                    if self.dataprimary.high[0] >= self.sellVal:
                        self.idealSellSig = True
                    self.sellSetup = False
                    self.sellCountdown = 0
                    
        # Trade only if no pending order and live data
        if not self.order and self.live:
            if not self.position:
                if self.buySig:
                    if self.p.stoploss_dist > 0:
                        stoplossPrice = self.dataprimary.close[0] - self.p.stoploss_dist
                        self.buy_bracket(stopprice=stoplossPrice, exectype=bt.Order.Market)
                    else:
                        self.buy()
                elif self.sellSig:
                    if self.p.stoploss_dist > 0:
                        stoplossPrice = self.dataprimary.close[0] + self.p.stoploss_dist
                        self.sell_bracket(stopprice=stoplossPrice, exectype=bt.Order.Market)
                    else:
                        self.sell()
            else:
                if self.position.size > 0 and (self.sellSig or self.idealSellSig):
                    self.close()
                elif self.position.size < 0 and (self.buySig or self.idealBuySig):
                    self.close()
                    
        # Log the closing price of the series from the reference
        self.log("Close {} TD SeqShort {} TD SeqLong {} TD CDBuy {} TD CDSell {}".format(self.dataclose[0], self.tdss, self.tdsl, self.buyCountdown, self.sellCountdown))

class observer(btobserver):
    plotinfo = dict(plot=True, subplot=False, plotlegend=False, 
                    plotlinelegend=False, plotlinevalues=False, 
                    plotabove=True, plotname="TD Sequential",)
    lines = ('buy', 'buy_ideal', 'sell', 'sell_ideal', 'seq_up_1', 
            'seq_up_2', 'seq_up_3', 'seq_up_4', 'seq_up_5', 
            'seq_up_6', 'seq_up_7', 'seq_up_8', 'seq_up_9', 
            'seq_up_1_b', 'seq_up_2_b', 'seq_up_3_b', 'seq_up_4_b', 
            'seq_up_5_b', 'seq_up_6_b', 'seq_up_7_b', 'seq_up_8_b', 
            'seq_up_9_b', 'seq_up_10_b', 'seq_up_11_b', 'seq_up_12_b', 
            'seq_down_1', 'seq_down_2', 'seq_down_3', 'seq_down_4', 
            'seq_down_5', 'seq_down_6', 'seq_down_7', 'seq_down_8', 
            'seq_down_9',
            'seq_down_1_s', 'seq_down_2_s', 'seq_down_3_s', 'seq_down_4_s', 
            'seq_down_5_s', 'seq_down_6_s', 'seq_down_7_s', 'seq_down_8_s', 
            'seq_down_9_s', 'seq_down_10_s','seq_down_11_s', 'seq_down_12_s',)
            
    plotlines = dict(
        buy_ideal = dict(marker='^', markersize=10.0, color='green',),
        buy = dict(marker='2', markersize=10.0, color='green',),
        sell_ideal = dict(marker='v', markersize=10.0, color='maroon',),
        sell = dict(marker='1', markersize=10.0, color='maroon',),
        seq_up_1 = dict(marker='$1$', markersize=6.0, color='black', ls='',),
        seq_up_2 = dict(marker='$2$', markersize=6.0, color='black', ls='',),
        seq_up_3 = dict(marker='$3$', markersize=6.0, color='black', ls='',),
        seq_up_4 = dict(marker='$4$', markersize=6.0, color='black', ls='',),
        seq_up_5 = dict(marker='$5$', markersize=6.0, color='black', ls='',),
        seq_up_6 = dict(marker='$6$', markersize=6.0, color='black', ls='',),
        seq_up_7 = dict(marker='$7$', markersize=6.0, color='black', ls='',),
        seq_up_8 = dict(marker='$8$', markersize=6.0, color='black', ls='',),
        seq_up_9 = dict(marker='$9$', markersize=6.0, color='black', ls='',),
        seq_up_1_b = dict(marker='$1$', markersize=6.0, color='blue', ls='',),
        seq_up_2_b = dict(marker='$2$', markersize=6.0, color='blue', ls='',),
        seq_up_3_b = dict(marker='$3$', markersize=6.0, color='blue', ls='',),
        seq_up_4_b = dict(marker='$4$', markersize=6.0, color='blue', ls='',),
        seq_up_5_b = dict(marker='$5$', markersize=6.0, color='blue', ls='',),
        seq_up_6_b = dict(marker='$6$', markersize=6.0, color='blue', ls='',),
        seq_up_7_b = dict(marker='$7$', markersize=6.0, color='blue', ls='',),
        seq_up_8_b = dict(marker='$8$', markersize=6.0, color='blue', ls='',),
        seq_up_9_b = dict(marker='$9$', markersize=6.0, color='blue', ls='',),
        seq_up_10_b = dict(marker='$10$', markersize=6.0, color='blue', ls='',),
        seq_up_11_b = dict(marker='$11$', markersize=6.0, color='blue', ls='',),
        seq_up_12_b = dict(marker='$12$', markersize=6.0, color='blue', ls='',),
        seq_down_1 = dict(marker='$1$', markersize=6.0, color='black', ls='',),
        seq_down_2 = dict(marker='$2$', markersize=6.0, color='black', ls='',),
        seq_down_3 = dict(marker='$3$', markersize=6.0, color='black', ls='',),
        seq_down_4 = dict(marker='$4$', markersize=6.0, color='black', ls='',),
        seq_down_5 = dict(marker='$5$', markersize=6.0, color='black', ls='',),
        seq_down_6 = dict(marker='$6$', markersize=6.0, color='black', ls='',),
        seq_down_7 = dict(marker='$7$', markersize=6.0, color='black', ls='',),
        seq_down_8 = dict(marker='$8$', markersize=6.0, color='black', ls='',),
        seq_down_9 = dict(marker='$9$', markersize=6.0, color='black', ls='',),
        seq_down_1_s = dict(marker='$1$', markersize=6.0, color='blue', ls='',),
        seq_down_2_s = dict(marker='$2$', markersize=6.0, color='blue', ls='',),
        seq_down_3_s = dict(marker='$3$', markersize=6.0, color='blue', ls='',),
        seq_down_4_s = dict(marker='$4$', markersize=6.0, color='blue', ls='',),
        seq_down_5_s = dict(marker='$5$', markersize=6.0, color='blue', ls='',),
        seq_down_6_s = dict(marker='$6$', markersize=6.0, color='blue', ls='',),
        seq_down_7_s = dict(marker='$7$', markersize=6.0, color='blue', ls='',),
        seq_down_8_s = dict(marker='$8$', markersize=6.0, color='blue', ls='',),
        seq_down_9_s = dict(marker='$9$', markersize=6.0, color='blue', ls='',),
        seq_down_10_s = dict(marker='$10$', markersize=6.0, color='blue', ls='',),
        seq_down_11_s = dict(marker='$11$', markersize=6.0, color='blue', ls='',),
        seq_down_12_s = dict(marker='$12$', markersize=6.0, color='blue', ls='',),
    )
    
    
    params = (
        ('bardist', 0.00005),  
    )
    
    def __init__(self):
        pass
        
    def next(self):
        # begin of sequence for long position
        if self._owner.tdsl > 0 and self._owner.tdsl < 10:
            name = 'seq_up_%d' % self._owner.tdsl
            attr = getattr(self.lines, name, False)
            attr[0] = self.data_low[0] - self.p.bardist
        
        # begin of sequence of short position
        elif self._owner.tdss > 0 and self._owner.tdss < 10:
            name = 'seq_down_%d' % self._owner.tdss
            attr = getattr(self.lines, name, False)
            attr[0] = self.data_high[0] + self.p.bardist
            
        if self._owner.buySetup:
            if self._owner.buyCountdown > 0 and self._owner.buyCountdown < 13:
                name = 'seq_up_%d_b' % self._owner.buyCountdown
                attr = getattr(self.lines, name, False)
                attr[0] = self.data_low[0] - (2 * self.p.bardist)
        elif self._owner.sellSetup:
            if self._owner.sellCountdown > 0 and self._owner.sellCountdown < 13 and self._owner.sellSetup:
                name = 'seq_down_%d_s' % self._owner.sellCountdown
                attr = getattr(self.lines, name, False)
                attr[0] = self.data_high[0] + (2 * self.p.bardist)
        
        if self._owner.buySig:
            self.lines.buy[0] = self.data_low[0] - (2 * self.p.bardist)
        elif self._owner.sellSig:
            self.lines.sell[0] = self.data_high[0] + (2 * self.p.bardist)
        elif self._owner.idealBuySig:
            self.lines.buy_ideal[0] = self.data_low[0] - (3 * self.p.bardist)
        elif self._owner.idealSellSig:
            self.lines.sell_ideal[0] = self.data_high[0] + (3 * self.p.bardist)
            

To plot this, you need to add the observer