@backtrader said in Setting a Stop loss and target in a strategy (missing piece in a sample):

Such a sample already exists. It is ATR-Based

See: https://www.backtrader.com/blog/posts/2016-07-30-macd-settings/macd-settings.html

(Of course, it is included in the sources)

Interesting. So if I understand correctly, in the example above, it's basically an ATR trailing stop, but it just uses a self.close() so it's kind of like an invisible stop loss, instead of updating a real stop loss by cancelling the old stop order and submitting a new stop order? Both ways will work? I wonder which is recommended?

@vladisld Were you able to verify whether the quick update of the stop loss works in live trading?

@ab_trader Wow, thanks! That stop update without cancel opens up a whole new world of possibilities. But as someone else mentioned, does it work on a live broker? Would the broker get the call to move the stop?

In the documentation: https://www.backtrader.com/blog/posts/2017-04-01-bracket/bracket/

There is code like:

def next(self):
        if self.orefs:
            return  # pending orders do nothing

def notify_order(self, order):
        if order.status == order.Completed:
            self.holdstart = len(self)

        if not order.alive() and order.ref in self.orefs:
            self.orefs.remove(order.ref)

 self.orefs = [o.ref for o in os]

        else:  # in the market
            if (len(self) - self.holdstart) >= self.p.hold:
                pass  # do nothing in this case

I am wondering what the point of all this is? It makes it look like it's not a good idea to have multiple brackets open at a time. I am indeed running into issues with duplicates/bracket orders hanging around. Can someone clarify if I should be using this template of "pending orders do nothing"?

Oh, documentation kinda makes it look like it should go on the root level but it should be nested in stopargs. My mistake.

Hi if I have code like this:

self.long_order = self.buy_bracket(exectype=bt.Order.Stop, stopexec=bt.Order.StopTrail, size=qty, valid=self.valid,
            limitprice=TP2_price,
            
            price=entry_price,
            
            stopprice=stoploss_price,
            # trailpercent=0.05,
        )

I see that its taking effect because I am getting trailing stop order notifications, and they are getting hit somehow as long as I specify stopexec=bt.Order.StopTrail.

Buy Stops            - 68
Sell Stops           - 120
Trailing Stop Losses - 179
Take Profits         - 9

However when I try to change the trailing stop, for example have it trail by 5%:

self.long_order = self.buy_bracket(exectype=bt.Order.Stop, stopexec=bt.Order.StopTrail, size=qty, valid=self.valid,
            limitprice=TP2_price,
            
            price=entry_price,
            
            stopprice=stoploss_price,
            trailpercent=0.05,
        )

I get the same result, the value is not being adjusted.

Buy Stops            - 68
Sell Stops           - 120
Trailing Stop Losses - 179
Take Profits         - 9

Is this what you're looking for?

self.stochRSI = bt.talib.STOCHRSI()

Cause you have these: https://mrjbq7.github.io/ta-lib/funcs.html

I am trying to set up this risk management strategy and not sure how much is reasonable with the current feature set. I could use some advice and suggestions. And if not, other alternative ideas or changes to the strategy are much appreciated!

Let's say I want to take a long with this setup:

Take profit 2
Take profit 1
Buy stop entry
Stop loss (after TP1 is hit, move this up to breakeven, then trail it while reaching for TP2)

We enter with a buy stop also set with a stop loss and take profit. (I'm assuming this best way to do this is with a bracket order?)

self.buy_bracket(exectype=bt.Order.Limit,
  limitprice=TP1,
  price=buystop,
  stopprice=stoploss,
)

After TP1 is hit, close 50% of the position. (Is there a way to close out only half of the position? It seems like it might be easier/better to just open 2 positions at once, one for TP1 and another for TP2?)

Move the stop loss up to the entry price to breakeven, begin trailing it now. (It doesn't seem like I can update a stop loss?)

Using the other 50% left in the trade, try to hit TP2 as well.

Is this reasonable or should I just keep it simple and just trying to set it all up at the beginning with 2 orders, even though it's not exactly what I want? Like this:

self.buy_bracket(exectype=bt.Order.Limit,
  limitprice=TP1,
  price=buystop,
  stopprice=stoploss,
  size=0.5,
)

self.buy_bracket(exectype=bt.Order.Limit,
  limitprice=TP2,
  price=buystop,
  stopprice=stoploss, # can this initial value also be set with the trail?
  size=0.5,

  stopexec=bt.Order.StopTrail,
  trailamount=3*0.001, # trailamount or trailpercent but not both
  trailpercent=7,
)

(If using a trailing stop, can I set the initial stop loss too or only the trailamount or trailpercent? Also, is it possible to make it dynamically change more specifically than a fixed amount or percent e.g. trail the stop loss at # pips below last # candles low? If I can't do that, guess I should just start it off with 2*ATR?)

Thanks!

I get this too and I'm not sure why.

For example, I have some code that counts a streak so it keeps upping the streak for the same piece of data, haha.

Data0, 0012, 05-12 21:51:58, C 107.130000, O 107.120000, 12
Data0, 0012, 05-12 21:51:58, C 107.130000, O 107.120000, 13
Data0, 0012, 05-12 21:51:58, C 107.130000, O 107.120000, 14
Data0, 0012, 05-12 21:51:58, C 107.130000, O 107.120000, 15
Data0, 0012, 05-12 21:51:58, C 107.130000, O 107.120000, 16
Data0, 0012, 05-12 21:51:58, C 107.130000, O 107.120000, 17

I noticed using the length of the data to dedup like this helps, but I'm not sure if I'm supposed to be doing this or not.

    def next(self):
        # dedup
        if self.lastlen and len(self.data0) == self.lastlen: return
        self.lastlen = len(self.data0)

Please ignore this typo

@booboothefool said in Can't seem to get Renko to show up correctly on forward testing:

        if self.c < self.o and self.streak <= -selfrequired_streakthres:

if self.c < self.o and self.streak <= -self.required_streak:

e.g.
2 green bars = +2
2 red bars = -2

You get the idea. Thanks!