"Looking at the code, it's not clear to me what does the "high side" (the one corresponding to the limitexec) order does."

meaning what does the highorder do in this one case --I understand the concept of high order in general.--

When I do a print:

                            print(str(this_order[0]))
                            print(str("+++++++++++++++++++++++"))
                            print(str(this_order[2]))

-----------------------
Ref: 755
OrdType: 0
OrdType: Buy
Status: 1
Status: Submitted
Size: 1
Price: 99.37
Price Limit: 99.27
TrailAmount: None
TrailPercent: None
ExecType: 2
ExecType: Limit
CommInfo: None
End of Session: 737679.9999999999
Info: AutoOrderedDict([('name', 'main')])
Broker: None
Alive: True
+++++++++++++++++++++++
Ref: 756
OrdType: 1
OrdType: Sell
Status: 1
Status: Submitted
Size: -1
Price: None
Price Limit: None
TrailAmount: None
TrailPercent: None
ExecType: 2
ExecType: Limit
CommInfo: None
End of Session: 737679.9999999999
Info: AutoOrderedDict([('name', 'limit')])
Broker: None
Alive: True
-----------------------

The first one is a buy limit with an entry price of 99.37 and a stop loss of 99.27 (?)

but what about the second one? What does a Limit sell order with a price of None and a price Limit of None does?

Consider this order:

                            this_order  = self.sell_bracket(exectype   = backtrader.Order.Limit,
                                                            stopexec   = None,
                                                            price      = price, 
                                                            data       = self.datas[0], 
                                                            size       = size, 
                                                            stopprice  = None,
                                                            plimit     = round(price + .1, 2))

Changing the above to set limitexec to None changes the results a lot.
Looking at the code, it's not clear to me what does the "high side" (the one corresponding to the limitexec) order does.

Can someone more familiar explain what sell_bracket does when limitprice is None and limitexec is bt.Order.Limit?

So just as self.order.issell() tells me whether the order is sell or buy, is there a way to querry self.order to know if it is the children or the parent of a bracket order?

I place only limit and bracket orders. I would like to know, for outstanding orders which is which.

• Is this particular order part of a bracket order
  --the sort created by self.buy_bracket(limitprice=14.00, price=13.50, stopprice=13.00)

and if so, is it child in a bracket or the parent?

• or a plain vanilla limit order --the sort created by self.sell(exectype = backtrader.Order.Limit, ...--

what I think should work is the following test:

                    if self.order:
                        for this_order in self.order:
                            if this_order.issell():
                                if not isinstance(this_order.price, type(None)):
                                   #this is a parent order or a plain vanilla limit, not a child

Can anyone confirm?

@kav said in How to cancel only parent order in bracket.:

I meant how to cancel only child order in bracket (can't find the edit button on this forum somehow).

no, I really meant the parent order. Anyone knows where the edit button is on this forum?

To cancel only parent order, can I use:

                        if self.order:
                            for this_order in self.order:
                                if this_order.issell():
                                    if not isinstance(this_order.price, type(None)):
                                       cancel(this_order)

I meant how to cancel only child order in bracket (can't find the edit button on this forum somehow).

Suppose I want to cancel all sell orders. I do:

                        if self.order:
                            for this_order in self.order:
                                if this_order.issell():
                                    self.cancel(this_order)

but what if some of these orders are children orders left from filled brackets orders:

--to keep the parlance of BT, main of the tripled [main, stop, limit] was a buy and filled. Now stop and limit are left (two sells). I want to delete all orders that are both main and sells. How do I do that?

Thanks, worked like a charm. As usual, thank you for the prompt answer and the references;)

Hi all,

I have created a custom broker by modifying a couple of functions from
/backtrader/brokers/bbroker.py
(calling the new file mybbroker.py and putting it in my own code directory, -- not in the same folder as the original bbroker.py).

Now my question is: how can I call this one to be used instead?

I tried to add a line

import mybroker

on top of the code, and though the import happens, it's still the original broker that gets used when I do:

import backtrader
import mybroker

cerebro   = backtrader.Cerebro(maxcpus = 1)
cerebro.addobserver(backtrader.observers.Broker)
cerebro.addstrategy(StrategyBaseTradingplusplus)        
data      = PandasDataStrat1(dataname     = dataframe, 
                                     datetime     = -1, 
                                     open         = -1, 
                                     high         = -1, 
                                     low          = -1, 
                                     close        = -1,
                                     volume       = -1,
                                     openinterest = None)
cerebro.adddata(data)
        
cerebro.broker.setcash(100000.0)
cerebro.broker.setcommission(commission = 0.2, 
                              margin     = 1000.0, 
                              mult       = 100.0)
cerebro.broker.set_filler(backtrader.broker.filler.FixedBarPerc(perc = 100.0))
               
cerebro.run()

So my question is: How to use my custom broker?