@backtrader So, it is possible that close could issue a sell order, if there was not a buy order open?

@tw00000 Any thoughts @backtrader ?? I really appreciate your advice you can give it.

In particular, I'm most concerned about the fact that it's opening short trades even though I'm not using sell anywhere in my code!

@backtrader said in Set minimum trade time / don't sell until certain amount of time has elapsed:

(time_now - time_market_entry) >= time_delta ?

Yeah, that's basically what I've done, but apparently incorrectly.

Here's what i'm currently doing but it seems to be generating some odd results:

def __init__(self):
    self.startcash = self.broker.getvalue()
    self.custom_orders = {}
    for i, d in enumerate(self.datas):

        # Instantiate order keeper for all your datas
        self.custom_orders[d] = dict()

def next(self)
    '''
    ...
    '''

    for index, data in enumerate(self.datas):
        datetime, dataname = self.datetime.date(), data._name

        pos = self.getposition(data).size

        # If we're not in a position, and we have a long trade signal, place a buy
        if not pos and trade_signal == True:
            self.custom_orders[data]['entry'] = self.buy(
                                data = data,
                                exectype = bt.Order.Limit,
                                price = data.close[0],
                                transmit = True,
                                info = {'ticker':dataname, 'price_range':(round(data.low[0], 2), round(data.high[0], 2)), 
                                    'direction':'LONG',  'type':'Limit Entry', 
                                    'SL': stop_loss, 'TP': take_profit, 'datetime': datetime},
                                )

        # If we're already in a position, look for an exit
        if pos:

            # Retrieve order info
            entry_order_info = self.custom_orders[data]['entry'].info['info']

            # Check if the order was opened a day ago (to avoid PDT)
            if (entry_order_info['datetime'] + pd.Timedelta(days=1)) < datetime:

                if np.any(np.array([data.open[0], data.high[0], data.low[0], data.close[0]]) < entry_order_info['SL']):
                    self.custom_orders[data]['stop_loss'] = self.close(
                                        data = data,
                                        info = {'ticker':dataname, 'price_range':(round(data.low[0], 2), round(data.high[0], 2)), 
                                            'direction':'LONG', 'type':'Stop Loss', 
                                            'setup': 'close long trade SL', 'datetime': datetime},
                                        )

                elif np.any(np.array([data.open[0], data.high[0], data.low[0], data.close[0]]) > entry_order_info['TP']):
                    self.custom_orders[data]['take_profit'] = self.close(
                                        data = data,
                                        info = {'ticker':dataname, 'price_range':(round(data.low[0], 2), round(data.high[0], 2)), 
                                            'direction':'LONG', 'type':'Take Profit', 
                                            'setup': 'close long trade TP', 'datetime': datetime},
                                        )

Weird things:

1. Some trades are being closed after 1 bar, despite my logic seeming to point to this not being allowed

2. There are short trades being opened?!

    trade_analyzer = strategy.analyzers.trade_analyzer.get_analysis()
    print("N short trades: {}".format(trade_analyzer.short.total))
    print("N long trades: {}".format(trade_analyzer.long.total))
    print("Average trade length: {}".format(trade_analyzer.len.average))
    print("Max trade length: {}".format(trade_analyzer.len.max))
    print("Min trade length: {}".format(trade_analyzer.len.min))

N short trades: 2                                                                                                                                                                                           
N long trades: 27                                                                                                                                                                                           
Average trade length: 20.103448275862068                                                                                                                                                                    
Max trade length: 33                                                                                                                                                                                        
Min trade length: 1  

(Timeframe is 1H, and is correctly configured)

PS: I also tried market orders for the entry, thinking that might be the problem (i.e. limit orders not being executed for a while and then the close logic detecting when the order was placed not executed). Different results, but similar.

PPS: I'm interested in hearing the correct use of data vs. dataname in my code here, when being used in placing orders, accessing my custom_orders dictionaries inside of next, etc.

I would like to set up a strategy that, after a Buy, will not consider a Sell signal until a certain amount of time has elapsed. A clear use-case for this is intraday strategies that might trigger PDT (Pattern Day Trader) regulations, so we need to hold a ticker at least overnight (if bought anytime on Tuesday, cannot sell until 9:30am EST on Wednesday).

I'm thinking about keeping track of the trade open time in a custom object in next() then evaluating it during a future next(), but I imagine this could get funky in ways I can't imagine right now, especially if I was trying to use bracket orders as well.

On that note, another ideal way to think about it would be, when setting up the bracket orders, to be able to se a "not valid before" on the stop loss and take profit, sort of like the opposite of valid_until.

What would be the most backtrader-y approach to this problem?

Thanks for your thoughts.

In: https://www.backtrader.com/docu/trade.html?highlight=trade

It reads:

isopen (bool): records if any update has opened the trade

I'm wondering which of these options this refers:

1. Trade was filled
2. Trade was sent to broker
3. Trade was accepted

Here's what I'm trying to achieve:

At the end of a backtest, I'm saving all the trades to a pickle file so that I can examine them

I would like to know, for each order (buy / sell / close): when the order was sent to the broker and when the order was filled.

Here's what I have so far, but I'm not sure what I'm getting from trade.dtopen:

for index, data in enumerate(strategy.datas):
        dataname = data._name

        data_trades = strategy._trades[data][0]
        trades = []
        for trade in data_trades:
            try: 
                trades.append({'ticker' : trade.data._name,
                                'bar_closed' : len(trade.data),
                                'trade_ref' : trade.ref,
                                'pnl' : round(trade.pnl, 2),
                                'bar_opened' : trade.baropen,
                                'date_opened' : trade.data.num2date(trade.dtopen),
                                'bar_closed' : trade.barclose,
                                'date_closed' : trade.data.num2date(trade.dtclose),
                                'n_bars_open_for' : trade.barlen,
                                'entry_trade' : trade.history[0]['event']['order'].info,
                                'exit_trade' : trade.history[1]['event']['order'].info,
                                'entry_price' : trade.history[0]['event']['price'],
                                'exit_price' : trade.history[1]['event']['price']
                                })
            except Exception as e:
                pass

Thanks for any assistance!

I figured it out, I think!

Since I was placing limit orders in both directions, and limit orders executed at your defined price or better, both long and short brackets were trying to execute simultaneously. I changed these to 'Stop' orders (which is kind of like market-buy-if-touched, for this purpose, right?) I get normal cancellation behavior, or like I would expect:

*SUBMITTED* 185.56 LL_style open long trade (184.62, 184.95) 2018-09-14 2018-09-14 14:45:00
*SUBMITTED* 182.78 LL_style close long trade SL (184.62, 184.95) 2018-09-14 2018-09-14 14:45:00
*SUBMITTED* 186.95 LL_style close long trade TP (184.62, 184.95) 2018-09-14 2018-09-14 14:45:00
*SUBMITTED* 184.01 LL_style open short trade (184.62, 184.95) 2018-09-14 2018-09-14 14:45:00
*SUBMITTED* 182.63 LL_style close short trade TP (184.62, 184.95) 2018-09-14 2018-09-14 14:45:00
*SUBMITTED* 186.77 LL_style close short trade SL  (184.62, 184.95) 2018-09-14 2018-09-14 14:45:00
*ACCEPTED* 185.56 LL_style open long trade (184.62, 184.95) 2018-09-14 2018-09-14 14:45:00
*ACCEPTED* 182.78 LL_style close long trade SL (184.62, 184.95) 2018-09-14 2018-09-14 14:45:00
*ACCEPTED* 186.95 LL_style close long trade TP (184.62, 184.95) 2018-09-14 2018-09-14 14:45:00
*ACCEPTED* 184.01 LL_style open short trade (184.62, 184.95) 2018-09-14 2018-09-14 14:45:00
*ACCEPTED* 182.63 LL_style close short trade TP (184.62, 184.95) 2018-09-14 2018-09-14 14:45:00
*ACCEPTED* 186.77 LL_style close short trade SL  (184.62, 184.95) 2018-09-14 2018-09-14 14:45:00
*COMPLETED* 184.01 LL_style open short trade (184.62, 184.95) 2018-09-14 2018-09-14 16:00:00
*CANCELING* LL_style open long trade LONG 2018-09-14 16:00:00
*COMPLETED* 183.27 LL_style open short trade (184.05, 184.45) 2018-09-13 2018-09-14 17:00:00

Until I find out later that something else mysteriously is going wrong, I think that solves it :) Hopefully this trail of tears helps someone in the future

@backtrader said in Opening bracket limit buy and bracket limit sell order at same time:

Well, you call addinfo with named arguments

Could you show a quick example?

Another version I'm attempting (also not working):

In my init:

self.bracket_orders = {}

After my bracket orders in next:

self.bracket_orders[self.shortside.ref] = self.longside
self.bracket_orders[self.longside.ref] = self.shortside

In my notify_order:

if order.status in [order.Completed]:
    self.cancel(self.bracket_orders[order.ref])

Trying to get creative here!

This one ends up with a strange dance:

*ACCEPTED* 144.67 open long trade 2017-09-06
*ACCEPTED* 143.22 close long trade SL 2017-09-06
*ACCEPTED* 147.2 close long trade TP 2017-09-06
*ACCEPTED* 144.21 open short trade 2017-09-06
*ACCEPTED* 141.69 close short trade TP 2017-09-06
*ACCEPTED* 145.65 close short trade SL  2017-09-06
*COMPLETED* 144.67 open long trade 2017-09-06
*CANCELING* open short trade SHORT
*COMPLETED* 144.21 open short trade 2017-09-06
*CANCELING* open long trade LONG

Where you can see that both orders end up canceled for some reason

@backtrader said in Opening bracket limit buy and bracket limit sell order at same time:

You probably want to check the order reference of the main order of a bracket as the key for a dictionary entry which contains a list with the orders of the other bracket (you would only need to cancel the main opposite order though)

Here's what I have so far:

In my next, after all of the code to create the brackets:

self.shortside.addinfo(bracket_orders = {self.shortside.ref: self.longside, self.longside.ref: self.shortside})
self.longside.addinfo(bracket_orders = {self.shortside.ref: self.longside, self.longside.ref: self.shortside})

And then in notify_order:

        if order.status in [order.Completed]:
            print(dict(order.info)['info']['bracket_orders'][order.ref])
            self.cancel(dict(order.info)['info']['bracket_orders'][order.ref])

This returns the error KeyError: 'bracket_orders'.

I'm attempting to use this method I found in the Orders docs:

info: custom information passed over method addinfo(). It is kept in the form of an OrderedDict which has been subclassed, so that keys can also be specified using ‘.’ notation

But I haven't yet figured out how to use it, which I'm hoping allows you to add information to an order object.

Even then, I think I could be a ways off, as "self.shortside" will be overwritten every time a new order comes into the pipeline

@backtrader said in Opening bracket limit buy and bracket limit sell order at same time:

Yes, but when one of brackets is active (because its middle order has executed) the other is still in the system awaiting activation. You probably want to manage that.

I'm pretty sure this is my current problem. Could just be 3:20am brain, but I can't figure out how to manage it. I thought that by checking in notify_order if an order is (for example) a buy, and then checking if it's an "open" order, then canceling the other (sell) bracket, I would be avoiding this issue?