The purpose of this post is to see if there is an interest in forking backtrader into an ongoing and consolidated ‘living’ project.

Currently there are a number of reasons for this:

1. Backtrader’s creator has deservedly moved on to greener pastures and the original code is locked under his git account so no updates can be made. This will make the code stale over time and discourage new users.
2. There are minor bug fixes that need implementing and future ones will come up with changes in the world.
3. Many people have made great enhancements already implemented and they are not in the core system.
4. There are many forks in various stages of development fragmenting the project.
5. Backtrader needs to belong to the community now, not any one person.

I would propose that we create a central ‘new’ forked backtrader with a fresh start, start with a few keen people as administrators on git. I would suggest that the order of importance for implementing would be first bug fixes and second enhancements that already exist in the world.

We could invite people through this forum and active solicitation to bring the code enhancements to the new central backtrader.

After that, we can look at new improvements down the road. Who knows, maybe there are people out there who would be keen to work on such a project?

I would be prepared to house the new version and work on it. I’m hoping that in the beginning at least that some others might volunteer?

Backtrader is an awesome library and it will surely die if we don’t organize ourselves a bit.

Let me know your thoughts.

ta-lib is the python wrapper for the well established Technical Analysis Library external to backtrader.

Backtrader makes use of this library with it's own connection to the ta-lib. These indicators are also call TA-Lib in backtrader, hence more confusion. You will need ta-lib python wrapper installed to use this.

The last library is the very newly minted bta-lib. This was created by the maker of backtrader as a handy library for doing technical analysis when using pandas dataframes. In a nutshell, you can put in a OHLCV dataframe and BTA-LIB will spit out the indicator. It works quite well and is easier to use that the original ta-lib library.

When you get your dictionary to this stage, you need the datetime key and the second column, which is value, to send to quantstats.

You do this by creating a dataframe from the dictionary and then eliminating the cash column. Once you have this dataframe, you can then put it into your quantstats functions. I had success with a couple of the function but got an error on the reports.html tearsheet. This is a problem you'll have to debug in quantstats. ( I suspect this works more natively from inside Jupyter)

df_values = pd.DataFrame(results[0].analyzers.getbyname("cash_market").get_analysis()).T
    df_values = df_values.iloc[:, 1]
    qs.extend_pandas()

    qs.reports.html(df_values, "SPY", output="qs.png")
    # qs.plots.snapshot(df_values, "SPY")
    # print(qs.stats.sharpe(df_values))

The code you've shared looks highly unorthadox for backtrader. Could we take a step back and you tell us what you are trying to accomplish in general, without any solutions? We can then tell you if maybe there's a better way to handle things.

Your question is unclear to me. Are you looking for trade position (number of units long or short), or if an order is buy sell?

For trade position in next use:

getposition(data=None, broker=None)

For order:
Strategy class offers three methods to assist you with orders.

User Methods:
    isbuy(): returns bool indicating if the order buys
    issell(): returns bool indicating if the order sells
    alive(): returns bool if order is in status Partial or Accepted

I took the liberty of writing up the code.

import datetime
import backtrader as bt
import math

class LogReturns(bt.Indicator):
    params = (
        ("log_period", 1),
    )
    lines = ('logreturns',)

    def next(self):
        # This makes sure enough bars have passed before trying to calcualte the log return.
        if len(self) < self.p.log_period:
            return
        self.l.logreturns[0] = (math.log(self.datas[0].close[0] / self.datas[0].close[-1]) / self.p.log_period) * 100


class Strat(bt.Strategy):
    params = dict(log_period=1)

    def log(self, txt, dt=None):
        """ Logging function fot this strategy"""
        dt = dt or self.data.datetime[0]
        if isinstance(dt, float):
            dt = bt.num2date(dt)
        print("%s, %s" % (dt.date(), txt))

    # Added log return to the signal printout.
    def print_signal(self):
        self.log(
            "o {:7.2f}\th {:7.2f}\tl {:7.2f}\tc {:7.2f}\tlog_return {:3.3f}".format(
                self.datas[0].open[0],
                self.datas[0].high[0],
                self.datas[0].low[0],
                self.datas[0].close[0],
                self.lr[0],
            )
        )

    def __init__(self):
        self.lr = LogReturns(log_period=self.p.log_period)


    def next(self):
        self.print_signal()


if __name__ == "__main__":

    cerebro = bt.Cerebro()

    for s in ['AAPL']:
        data = bt.feeds.YahooFinanceData(
            dataname=s,
            timeframe=bt.TimeFrame.Days,
            fromdate=datetime.datetime(2019, 11, 4),
            todate=datetime.datetime(2020, 11, 4),
            reverse=False,
        )
        cerebro.adddata(data)

    cerebro.addstrategy(Strat)

    # Execute
    cerebro.run()

Which prints out something like:

2019-11-04, o   63.07	h   63.20	l   62.60	c   63.12	log_return -55.771
2019-11-05, o   63.01	h   63.29	l   62.83	c   63.03	log_return -0.143
2019-11-06, o   62.94	h   63.11	l   62.59	c   63.05	log_return 0.032
2019-11-07, o   63.61	h   64.01	l   63.46	c   63.78	log_return 1.151
2019-11-08, o   63.60	h   64.03	l   63.15	c   63.95	log_return 0.266
2019-11-11, o   63.50	h   64.53	l   63.50	c   64.46	log_return 0.794

When you create the order make your order equal to a variable, say: self.order Also keep track of the latest traillimit price with another variable, in this case self.trail_price.

You will need to initialize them as None. The changing limit can be found in the order as the created price, so order.created.price.

Just compare the created price to your tracking trail_price and you can print or log whenever they are not equal.

Here's full code implementation:

def next(self):

    if not self.position and self.buy_sig:
        self.order = self.buy(size=1, exectype=bt.Order.StopTrail, trailamount=5)
        self.trail_price = self.order.created.price
        self.log(
            f"ORDER MADE: close {self.data.close[0]}, trail price {self.trail_price}"
        )
    elif self.position and self.sell_sig:
        self.sell()
    else:
        pass

    if self.trail_price and self.order is not None:
        if self.trail_price != self.order.created.price:
            self.log(
                f"TRAIL PRICE CHANGES: \tclose {self.data.close[0]:.2f},"
                f"\told trail price {self.trail_price:.2f},"
                f"\tnew trail price {self.order.created.price:.2f}"
            )
            self.trail_price = self.order.created.price

Output:

2020-01-29 12:10:00, ORDER MADE: close 3274.75, trail price 3279.75
2020-01-29 12:25:00, TRAIL PRICE CHANGES: 	close 3274.50, 	old trail price 3279.75, 	new trail price 3279.50
2020-01-29 12:35:00, TRAIL PRICE CHANGES: 	close 3273.75, 	old trail price 3279.50, 	new trail price 3278.75
2020-01-29 13:00:00, TRAIL PRICE CHANGES: 	close 3273.25, 	old trail price 3278.75, 	new trail price 3278.25
2020-01-29 13:10:00, TRAIL PRICE CHANGES: 	close 3272.00, 	old trail price 3278.25, 	new trail price 3277.00
2020-01-29 13:30:00, BUY EXECUTED, Price: 3277.00, Cost: -3308.50, Comm 0.00

I think you might have a few issues at play:

First, you are setting the buy size of your trade to be the maximum possilbe.

size = int(self.broker.getcash() / self.data.open)

This is problematic because in an upward trending market, the total cash you need will be greater than what you have, resulting in a 'margin' failure of the order. To set up your algorithm, use a trade value much smaller than the market value, say 50%. You can adjust the buffer later. Some people will use the volatility or trading range to assist in setting the buffer. I typically will just you 2.5% or so and see if I get stopped out.

Second, you have two sell orders possible for every trade. So you need to have better verification if the trade should happen. When selling if there is a crossover down, you could use close instead of sell. This will only close an open position for the amount it is open. See here.

if self.position:  # in the market    
    if self.Trend < 0:  # cross to the downside it's DOWN trend
        self.order = self.close()

Next, your sell stop trail has a very small value (0.02) compared to the size of unit price (5000). This means you are definitly going to get stopped out right away just with regular volatility.

The final issue is that you need to be able to kill the stop trail order if your sell due to crossdown occurs. As it stands, if you sell due to the cross down, your stop sell is still out there waiting to be triggered.

You can solve this by cancelling the order when you sell by crossdown.

if self.position:  # in the market    
    if self.Trend < 0:  # cross to the downside it's DOWN trend
        self.order = self.close()
        self.cancel(self.stop_loss)

In next you have assigend your entry order object to the variable self.order. When in notify_order, you access the current order object using the variable order. These are both order objects.

In an order object you can access the status of that object which is stores as in next self.order.status or in notify_order as order.status.

For completed orders this status variable will equal 4.

In your code, in next, you can use:

if self.order.status != self.order.Completed  etc.

or

if self.order.status != 4    etc.

The cancel is normal. It is cancelling the other side of the bracket, so if you fill on the take profit, the stop gets cancelled and vice versa. If you want a bit more information in your log you can show the order reference numbers.

Also as another side note, I notice you are assigning the size using order.size. Size is acutally tracked in order.created.size.

@Gleetche said in How does the code run in bt.strategy:

Can you point me out on which part of the docs will help with my answer?

At this stage you need to invest the time to learn the software. Start here. https://www.backtrader.com/docu/concepts/ And walk your way forward using the built examples.

Backtrader assumes a certain level of programming ability and doesn't attempt to teach you that. So you are going to have to grind it out. Be prepared for some stuff not to work, but once you've got the basic elements under your belt, come back and we'll get you going.

Good luck!

I meant tripple back quotes as per:

For code/output blocks: Use ``` (aka backtick or grave accent) in a single line before and after the block. See: http://commonmark.org/help/

Could you kindly insert all of the code into a comment using quotes? There's not enough information in your image to trouble shoot.

@LClassen I have verified the captcha is not working and new registration is not possible.

I believe only @backtraderadmin @backtrader have the keys to the forum.

This is awesome, thanks for sharing!

Couple of things jump out. The first is that you are creating:

self.o[d] = [o1, o2, o3]

But you don't use it anywhere. When entering next and your loop of datas you would normally check to make sure this list of live orders doesn't exists for that specific data otherwise you run the risk of filling orders twice, if your position is not filled right away.

In this case you are using market orders so you are probably only filling once before your checking of positions stops new orders. However, you should check for any live orders in the above mentioned dictionary before allowing orders to be created. I can see you had some code commented out for this.

def next(self):
        for i, d in enumerate(self.datas):      
            if not self.getposition(d).size and not self.order[d]: 

I would put this condition back in and manage my list better after this.

Remove that list for the data once there are no live orders left. You can check this in the completed notify orders section:

if len([o for o in self.o[order.data] if o.status < 4]) == 0:
    self.o[order.data] = None

One other minor point, if you datas are loaded already with:

lines = ("signal","prediction",)

Then this code is not necessary.

self.inds[d] = dict()
            self.inds[d]['close'] = d.close
            self.inds[d]['prediction'] = d.prediction
            self.inds[d]['signal'] = d.signal

You can simply refer to your data lines directly:

def next(self):
    for d in self.datas:
        d.close[0]
        d.prediction[0]
        d.signal[0]

@jennywestwong said in Stoploss Strategy of looking back X number of candles to see if it breached Y% relative to filled price.:

number

No problem. I'm sure if you spend a couple of weeks working through the docs, you'll be all set. I think this is how we all started. :o)

I'm not 100% sure your objective, but I can discuss some of your errors.

1. You are mixing your styles a bit, which may be causing confusion.

self.dataclose = self.datas[0].close
self.data.close.get
self.dataclose[0]

I emphasize this is my preference, and others will happily use shortcuts, but for me it always makes it easier if I identify the line using:
"""
self.datas[n]
"""
self.datas is a list of the the datas. n would be the number in the list. By always using this there is absolute clarity as to which line you are using.

2. Let's address your first main line:

roc2 = self.data.close.get(size=1, ago=-self.p.period)[0] * (1+ (self.p.threshold/100))

.get returns a python list of the size and starting a period ago. So a couple of things, using size one will return a list of size 1 from period 10 bars ago in this case. It would be much easier to write:

self.datas[0].close[-10]

3. Your next main issue in your second code block is:

self.dataclose = self.datas(-self.p.threshold).close

You are actually trying to find a datas line at -10, but I'm assuming you only have one data line. So this will fail.

4. This line of code attempts to build the roc2 line bar by bar.
   '''
   self.lines.roc2 = roc2
   '''
   You need to identify the bar for the lines.

self.lines.roc2[0] = roc2

Hope this helps.

You do have a lot going on that's probably causing you some trouble.

1. You are including methods inside of another method. long_stoploss inside next. This is bad practice.
2. You are trading self. data as a pandas object using .loc. It is not a pandas object.
3. Where does self.smooth_rsi come from? Maybe it's a thing I don't know about.
4. Your long_stoploss and short stoploss should be created as indicators.
5. You are calling self.crossover in next without identifying the bar using [0]
6. You are calling long_stoploss without using method () brackets.

The fact that you are getting any results at all is a mystery to me. I'm not trying to be harsh. My best advice for you at this time would be to spend time in the docs and replicate the examples you see there. Backtrader has a bit of a learning curve and it's difficult to wing it.

Good luck and come back again after you have a chance to absorb some of the material.

I do have a non-backtrader solution for this if you like. Let me know.

The reason you are getting the discprency is the nature of how ATR is calculated. ATR has the following definition:

The range of a day's trading is simply [high − low]. The true range extends it to yesterday's closing price if it was outside of today's range.

Note that ATR must have the ability to look back one period. This one period look back requirement means that all ATR calculations will need n+1 periods for warmup calculation.

You can check this yourself by putting say bt.ind.SMA by itself for n periods (5 in this case):

2015-07-08, Close: 30.64, sma: 31.37, 
2015-07-09, Close: 30.02, sma: 31.04, 

Now add in the ATR with the same period, and you will see the results start one period later.

2015-07-09, Close: 30.02, sma: 31.04, vol:  0.64
2015-07-10, Close: 30.82, sma: 30.88, vol:  0.70

None of this has anything to do with your function, but is a matter of how ATR is calculated.