i fixed issues with my datafeeds by adjusting the time to the end of the period they are on. Backtrader expects somehow the endtime of a period, while most data will have the starttime of a period as the datetime.

A custom csv feed with time adjustment which can be used to fix that:

import backtrader as bt
from backtrader.utils import date2num
from datetime import datetime, time, timedelta



def getstarttime(timeframe, compression, dt, sessionstart=None, offset=0):
    '''
    This method will return the start of the period based on current
    time (or provided time).
    '''
    if sessionstart is None:
        # use UTC 22:00 (5:00 pm New York) as default
        sessionstart = time(hour=22, minute=0, second=0)
    if dt is None:
        dt = datetime.utcnow()
    if timeframe == bt.TimeFrame.Seconds:
        dt = dt.replace(
            second=(dt.second // compression) * compression,
            microsecond=0)
        if offset:
            dt = dt - timedelta(seconds=compression*offset)
    elif timeframe == bt.TimeFrame.Minutes:
        if compression >= 60:
            hours = 0
            minutes = 0
            # get start of day
            dtstart = getstarttime(bt.TimeFrame.Days, 1, dt, sessionstart)
            # 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 == bt.TimeFrame.Days:
        if dt.hour < sessionstart.hour:
            dt = dt - timedelta(days=1)
        if offset:
            dt = dt - timedelta(days=offset)
        dt = dt.replace(
            hour=sessionstart.hour,
            minute=sessionstart.minute,
            second=sessionstart.second,
            microsecond=sessionstart.microsecond)
    elif timeframe == bt.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=sessionstart.hour,
            minute=sessionstart.minute,
            second=sessionstart.second,
            microsecond=sessionstart.microsecond)
    elif timeframe == bt.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
        if dt.day < last_day_of_month:
            dt = dt - timedelta(days=dt.day)
        dt = dt.replace(
            hour=sessionstart.hour,
            minute=sessionstart.minute,
            second=sessionstart.second,
            microsecond=sessionstart.microsecond)
    return dt


class CSVAdjustTime(bt.feeds.GenericCSVData):

    params = dict(
        adjstarttime=False,
    )

    def _loadline(self, linetokens):
        res = super(CSVAdjustTime, self)._loadline(linetokens)
        if self.p.adjstarttime:
            # move time to start time of next candle
            # and subtract 0.1 miliseconds (ensures no
            # rounding issues, 10 microseconds is minimum)
            new_date = getstarttime(
                self._timeframe,
                self._compression,
                self.datetime.datetime(0),
                self.sessionstart,
                -1) - timedelta(microseconds=100)
            self.datetime[0] = date2num(new_date)
        return res

If anyone needs this, here is a BBSqueeze indicator.

implementation is based on this: https://www.netpicks.com/squeeze-out-the-chop/

BBSqueeze

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

import backtrader as bt

from . import KeltnerChannel


class BBSqueeze(bt.Indicator):

    '''
    https://www.netpicks.com/squeeze-out-the-chop/

    Both indicators are symmetrical, meaning that the upper and lower bands or channel lines are the same distance from the moving average. That means that we can focus on only one side in developing our indicator. In our case, we’ll just consider the upper lines.

    The basic formulas we need are:

        Bollinger Band = Moving Average + (Number of standard deviations X Standard Deviation)
        Keltner Channel = Moving Average + (Number of ATR’s X ATR)

    Or if we translate this into pseudo-code:

        BBUpper = Avg(close, period) + (BBDevs X StdDev(close, period))
        KCUpper = Avg(close, period) + (KCDevs X ATR(period))

    The squeeze is calculated by taking the difference between these two values:

        Squeeze = BBUpper – KCUpper

    Which simplifies down to this:

        Squeeze = (BBDevs X StdDev(close, period)) – (KCDevs X ATR(period))
    '''

    lines = ('squeeze',)
    params = (('period', 20), ('devfactor', 2.0), ('movav', bt.ind.MovAv.Simple),)

    plotinfo = dict(subplot=True)

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

    def __init__(self):
        bb = bt.ind.BollingerBands(
            period=self.p.period, devfactor=self.p.devfactor, movav=self.p.movav)
        kc = KeltnerChannel(
            period=self.p.period, devfactor=self.p.devfactor, movav=self.p.movav)
        self.lines.squeeze = bb.top - kc.top

KeltnerChannel

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

import backtrader as bt


class KeltnerChannel(bt.Indicator):

    lines = ('mid', 'top', 'bot',)
    params = (('period', 20), ('devfactor', 1.5),
              ('movav', bt.ind.MovAv.Simple),)

    plotinfo = dict(subplot=False)
    plotlines = dict(
        mid=dict(ls='--'),
        top=dict(_samecolor=True),
        bot=dict(_samecolor=True),
    )

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

    def __init__(self):
        self.lines.mid = ma = self.p.movav(self.data, period=self.p.period)
        atr = self.p.devfactor * bt.ind.ATR(self.data, period=self.p.period)
        self.lines.top = ma + atr
        self.lines.bot = ma - atr

@curious_one your datetime is a string, try converting it to datetime objects. Look at pandas to_datetime() method.

df.Datetime = pandas.to_datetime(
            df.Datetime, format='%Y-%m-%d  %H:%M:%S')

@tsguo3 if you want to be sure, you can always read the source code.

BBSqueeze with configureable multiplicators for bb and keltner

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

import backtrader as bt

from . import KeltnerChannel


class BBSqueeze(bt.Indicator):

    '''
    https://www.netpicks.com/squeeze-out-the-chop/

    Both indicators are symmetrical, meaning that the upper and lower bands or channel lines are the same distance from the moving average. That means that we can focus on only one side in developing our indicator. In our case, we’ll just consider the upper lines.

    The basic formulas we need are:

        Bollinger Band = Moving Average + (Number of standard deviations X Standard Deviation)
        Keltner Channel = Moving Average + (Number of ATR’s X ATR)

    Or if we translate this into pseudo-code:

        BBUpper = Avg(close, period) + (BBDevs X StdDev(close, period))
        KCUpper = Avg(close, period) + (KCDevs X ATR(period))

    The squeeze is calculated by taking the difference between these two values:

        Squeeze = BBUpper – KCUpper

    Which simplifies down to this:

        Squeeze = (BBDevs X StdDev(close, period)) – (KCDevs X ATR(period))
    '''

    lines = ('squeeze',)
    params = (('period', 20), ('bbdevs', 2.0), ('kcdevs', 1.5), ('movav', bt.ind.MovAv.Simple),)

    plotinfo = dict(subplot=True)

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

    def __init__(self):
        bb = bt.ind.BollingerBands(
            period=self.p.period, devfactor=self.p.bbdevs, movav=self.p.movav)
        kc = KeltnerChannel(
            period=self.p.period, devfactor=self.p.kcdevs, movav=self.p.movav)
        self.lines.squeeze = bb.top - kc.top

Another indicator, Chandelier Exit

import backtrader as bt


class ChandelierExit(bt.Indicator):

    ''' https://corporatefinanceinstitute.com/resources/knowledge/trading-investing/chandelier-exit/ '''

    lines = ('long', 'short')
    params = (('period', 22), ('multip', 3),)

    plotinfo = dict(subplot=False)

    def __init__(self):
        highest = bt.ind.Highest(self.data.high, period=self.p.period)
        lowest = bt.ind.Lowest(self.data.low, period=self.p.period)
        atr = self.p.multip * bt.ind.ATR(self.data, period=self.p.period)
        self.lines.long = highest - atr
        self.lines.short = lowest + atr

@hfrog713 said in Converting a Tradingview Strategy to a Backtrader Strategy - EMA Crossover:

def next(self):
    if self.position.size:
        if self.crossover < 0:
            self.sell()
    elif self.crossover > 0:
        self.buy()

Here is a indention error, the elif self.crossover > 0

I fixed the issue with oanda broker. It will now assume, there is no stopside

When you create the datafeed, you need to specify the timeframe and compression your data is using. Backtrader will not identify it by itself.

So when you do:

 data_feed = CryptoPandasData(dataname=time_bars)

you would do it that way:

 data_feed = CryptoPandasData(dataname=time_bars, timeframe=bt.TimeFrame.Minutes, compression=1)

Hi

I have worked on converting a Pinescript indicator to backtrader.

I will describe some findings in the process, give some tips, show a example and so on.

variables
in pinescript, variables seem to work like lines in backtrader. So for every variable used in the script I have added a line:

pinescript:

setupCountUp = na

backtrader ind.__init__:

self.setup_sell = bt.LineNum(float('nan'))

conditions
to use methods like barssince, valuewhen from pinescript, which allows conditions like: setupCountUp == self.p.setup_bars the easiest method I found is to use numpy for this.

1. convert a line to a numpy array (using get(size=SIZE) to not work on complete line but only a defined range of data)

def line2arr(line, size=-1):
    if size <= 0:
        return np.array(line.array)
    else:
        return np.array(line.get(size=size))

2. provide methods which works as methods from pinescript: so I wrote the methods I needed.

def na(val):
    return val != val

def nz(x, y=None):
    if isinstance(x, np.generic):
        return x.fillna(y or 0)
    if x != x:
        if y is not None:
            return y
        return 0
    return x

def barssince(condition, occurrence=0):
    cond_len = len(condition)
    occ = 0
    since = 0
    res = float('nan')
    while cond_len - (since+1) >= 0:
        cond = condition[cond_len-(since+1)]
        if cond and not cond != cond:
            if occ == occurrence:
                res = since
                break
            occ += 1
        since += 1
    return res

def valuewhen(condition, source, occurrence=0):
    res = float('nan')
    since = barssince(condition, occurrence)
    if since is not None:
        res = source[-(since+1)]
    return res

rewriting

the process of rewriting the pinescript in python using backtrader was simple after this. basically it can be split up to:

1. look for vars, params, signals used in pinescript
2. define vars, params, signal in indicator
3. strip all plot related code from pinescript
4. rewrite pinescript code in indicators next method

plotting

since i only want to have signals as lines in indicator, I did not set all vars used in pinescript in the lines dict, but in init. So I had a better control of what the indicator is plotting. But the indicator had more values then just the signals, so how to handle them?
The solution was a observer, which takes care of plotting all other information, the indicator has. Here you can setup all the plot related code from pinescript.

some remaining issues

maybe some of you guys know answers for this:

Questions:

• is it possible to create lines with conditions (outside of __init__) like: self.line1 > val ?
• is there a way to get something like barssince, valuewhen natively in backtrader?

Issues:

• the code is not very good, since a lot of the code can be done better in python, but if you don't want to fiddle to much with it, this should be fine
• refactoring would make the code better readable

I hope, this will help some of you!
I will post the code of a indicator, observer and the pinescript methods in a next post below.

@hfrog713 said in Converting a Tradingview Strategy to a Backtrader Strategy - EMA Crossover:

def next(self):
    if self.position.size:
        if self.crossover < 0:
            self.sell()
    elif self.crossover > 0:
        self.buy()

Here is a indention error, the elif self.crossover > 0

@ultra1971 oh, i noticed now this topic is posted twice, i added some suggestions in https://community.backtrader.com/topic/3773/a-new-ib-integration-using-ib_sync/6

i created a pull request, to make this module installable via pip and moved the files to a module dir.

Seems to be working fine. Had no problems in running this module.

One thing as a suggestion:
Maybe class naming could be different than backtraders code to avoid confusion what store, broker, feed is being used. Both implementations are called IBStore, IBBroker, IBData

@ultra1971 great work, will try this out. Thanks for your work.

@aqa20 take a look here: https://community.backtrader.com/topic/1629/problem-with-resampling-1m-data-to-5m-15m/

@aqa20 approach two works because there you defined to what compreession you want to resample your data to. backtrader will check if the timestamp of current candle is over the period and forward the data when its over (which is basically every row, since you already use the matching timeframe/compression in your source data).
If you just define a data source and add it to bbacktrader, then backtrader does not know, what granularity your data has.
this is why you need to define in approach one also the compression of your data.

@aqa20 said in Different results with resample data and add data methods!:

@dasch Well that's what I've done already, check the code

no, you did not define the data correctly in approach one. you left out the compression, which is needed there.

but you need to define, what kind of data you are using. so in approach one you just don't define the data granularity which is required. the result should be the same after defining the compression in approach one.

@aqa20 so for 5 minutes you would use these params:

compression=5, timeframe=bt.TimeFrame.Minutes

for 1 hour data you would use these params:

compression=60, timeframe=bt.TimeFrame.Minutes

@aqa20 in your approach one you did not define the data compression, so all your csv are defined as 1 minute data, which is wrong. Try approach one with adding the param compression.