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

@curious_one You might be overthinking with the topline, blueline, redline variables. Try this simpler version.

def next(self):
# Simply log the closing price of the series from the reference
self.log('Close, %.2f' % self.dataclose[0])

# Check if an order is pending ... if yes, we cannot send a 2nd one
if self.order:
    return


if self.getposition().size == 0:
    if self.dataclose < self.bband.lines.bot:
        self.buy()
    elif self.dataclose > self.bband.lines.top:
        self.sell()

if (self.getposition().size > 0 and self.dataclose >= self.bband.mid) or (
        self.getposition().size < 0 and self.dataclose <= self.bband.mid):
    self.close()

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.

@mama1baba said in How to close a position if the stop loss wasn't triggered after "self.bar_executed + 1 ":

o1 = self.buy(
exectype= bt.Order.Market,
size = long_size
)

Try setting transmit = False on the first trade:

transmit (default: True)

Indicates if the order has to be transmitted, ie: not only placed in the broker but also issued. This is meant for example to control bracket orders, in which one disables the transmission for the parent and 1st set of children and activates it for the last children, which triggers the full placement of all bracket orders.

@mama1baba said in How to close a position if the stop loss wasn't triggered after "self.bar_executed + 1 ":

2021-01-08 19:00, Ref 031 : SL/TP Order Canceled/Margin/Rejected

Getting rejected because there's not enough cash to cover the sale. Try putting in a million dollars or something to see if the error goes away.

@ph-l-pp I'm sure there's an easier and more elegant solution, but this works.

@tigerandy I believe timeframe is showing the period of the Sharpe Ratio calcalation. e.g. annually, monthly, daily. Not ratios for each time period.

@alexgorbachev Options is not a use case for Backtrader. You should consider alternatives.

@luzzalgos When you resample, you are accessing the last of higher timeframes in each minute bar. So in the current minute bar, you are getting the ohlc of the last hour, day, etc.

To access the last hour of the last day, you will need to create a custom indicator that records that last hour's value at the end of the day, and then makes it available the next day for the entire day.

@alexgorbachev Can you share your code please?

@kfue Also check if tradingview is using leftedge or rightedge for displaying data. This could also cause a small error like you mention.

Backtrader uses:

rightedge (default: True)

Use the right edge of the time boundaries to set the time.

If False and compressing to 5 seconds the time of a resampled bar for seconds between hh:mm:00 and hh:mm:04 will be hh:mm:00 (the starting boundary

See resampling

@zetra-zetra Nice job and good luck!

@zetra-zetra Are you going to work in optimization?