Backtrader Community

ard9000

Once again I will share the answer to my own problem.

There wasn't enough cash to execute the target orders. I forgot the default BT broker doesn't appear to add to the cash position when selling short.

It now works as expected.

ard9000

@ard9000

About 2 minutes after hitting the Submit button, I figured part of it out. In the target order:

exit_order = self.buy(data_min, contracts = contracts, price = self.target_exit_price[stock], exectype = bt.Order.Limit)

contracts= should be size=

However now the order doesn't execute at all. Another example:

info: 2020-11-22 18:12:00, btc_usd: 38 order executed: price: 18499.32000, value: -171385.21, commm 0.00, stock price: 18477.59
info: 2020-11-22 18:13:00,  btc_usd: stop order placed at 18607.26000 ref: 39
info: 2020-11-22 18:13:00,  short exit order
info: 2020-11-22 18:13:00, Ref: 40
OrdType: 0
OrdType: Buy
Status: 1
Status: Submitted
Size: 9.264406151565797
Price: 18283.44
Price Limit: None
TrailAmount: None
TrailPercent: None
ExecType: 2
ExecType: Limit
CommInfo: None
End of Session: 737751.9999999999
Info: AutoOrderedDict()
Broker: None
Alive: True
info: 2020-11-22 18:13:00,  btc_usd: target exit order placed at 18283.44000   size:  9.264406151565797   ref: 40

short entry @ 18499.32000 for 9.26 BTC (order #38)
stop order placed at 18607.26000 (order #39)
target exit order placed at 18283.44000 size: 9.264406151565797 (order #40)

Now the price blows through 18283.44 and the order isn't executed.

info: 2020-11-22 18:13:00,  btc_usd: target exit order placed at 18283.44000   size:  9.264406151565797   ref: 40
info: 2020-11-22 18:15:00,  open trade position: 0.09   high: 18634.93    low: 18425.75
info: 2020-11-22 18:30:00,  open trade position: -0.28   high: 18544.54    low: 18404.46
info: 2020-11-22 18:45:00,  open trade position: 0.04   high: 18559.69    low: 18476.32
info: 2020-11-22 19:00:00,  open trade position: 0.08   high: 18498.77    low: 18391.64
info: 2020-11-22 19:15:00,  open trade position: -0.08   high: 18529.5    low: 18438.23
info: 2020-11-22 19:30:00,  open trade position: 1.32   high: 18515.03    low: 18242.75
info: 2020-11-22 19:45:00,  open trade position: 1.46   high: 18337.4    low: 18203.49
info: 2020-11-22 20:00:00,  open trade position: 2.85   high: 18306.32    low: 18103.14
info: 2020-11-22 20:15:00,  open trade position: 1.78   high: 18272.0    low: 18001.95
info: 2020-11-22 20:30:00,  open trade position: 2.98   high: 18266.51    low: 18090.24
info: 2020-11-22 20:45:00,  open trade position: 2.29   high: 18205.64    low: 18068.05

The bar lows are below 18283 beginning at 19:30:00 and the target exit order isn't executed. There is plenty of volume, 10000 on 1 minute bars. We continue on until the position reverses and the stop order (#39) is executed.

info: 2020-11-22 21:00:00,  open trade position: 2.06   high: 18264.64    low: 18157.17
info: 2020-11-22 21:15:00,  open trade position: 1.18   high: 18352.47    low: 18213.9
info: 2020-11-22 21:30:00,  open trade position: 1.86   high: 18347.79    low: 18224.15
info: 2020-11-22 21:45:00,  open trade position: 1.77   high: 18307.97    low: 18207.84
info: 2020-11-22 22:00:00,  open trade position: 1.79   high: 18304.43    low: 18199.04
info: 2020-11-22 22:15:00,  open trade position: 1.46   high: 18298.95    low: 18185.16
info: 2020-11-22 22:30:00,  open trade position: 0.98   high: 18396.54    low: 18281.96
info: 2020-11-22 22:45:00,  open trade position: 0.96   high: 18440.69    low: 18342.31
info: 2020-11-22 23:00:00,  open trade position: 0.99   high: 18445.94    low: 18341.38
info: 2020-11-22 23:15:00,  open trade position: 0.35   high: 18452.04    low: 18351.16
info: 2020-11-22 23:30:00,  open trade position: 0.17   high: 18529.39    low: 18429.5
info: 2020-11-22 23:45:00,  open trade position: -0.22   high: 18529.39    low: 18447.46
info: 2020-11-23 00:00:00,  open trade position: -0.01   high: 18529.39    low: 18448.26
info: 2020-11-23 00:15:00,  open trade position: 0.62   high: 18518.71    low: 18402.59
info: 2020-11-23 00:30:00,  open trade position: -0.17   high: 18522.75    low: 18402.67
info: 2020-11-23 00:45:00,  open trade position: 0.24   high: 18522.79    low: 18450.18
info: 2020-11-23 01:00:00,  open trade position: 0.36   high: 18503.64    low: 18450.02
info: 2020-11-23 01:15:00,  open trade position: 0.82   high: 18460.74    low: 18366.17
info: 2020-11-23 01:30:00,  open trade position: 1.15   high: 18400.0    low: 18316.43
info: 2020-11-23 01:45:00,  open trade position: 0.79   high: 18410.06    low: 18337.29
info: 2020-11-23 02:00:00,  open trade position: -0.19   high: 18562.88    low: 18381.06
info: 2020-11-23 02:15:00,  open trade position: 0.20   high: 18525.35    low: 18447.73
info: 2020-11-23 02:30:00,  open trade position: -0.01   high: 18541.55    low: 18458.79
info: 2020-11-23 02:45:00,  open trade position: 0.29   high: 18527.23    low: 18459.26
info: 2020-11-23 03:00:00,  open trade position: -0.06   high: 18517.56    low: 18441.45
info: 2020-11-23 03:12:00, btc_usd: 39 order executed: price: 18607.26000, value: -171385.21, commm 0.00, stock price: 18584.88
info: 2020-11-23 03:12:00, Trade value: 0.00, P/L -1000.00, P/L comm: -1000.00

Is there any reason why buy order #40 isn't being executed, when there is plenty of volume and the price moved right through it?

In the first example I shared, after changing contracts= to size=, the same thing happens. Instead of a partial close it doesn't close the position at all.

ard9000

I have a well functioning script I've been running on FX pairs for several years. It works well. Recently I converted the script to test on BTC with fractional share sizing.

Per this post here, I added this bit of code to the strategy with the extra class for fractional sizing:

https://www.backtrader.com/blog/posts/2019-08-29-fractional-sizes/fractional-sizes/

For long positions, I can take entries with fractional positions and using self.close(), I can close the long position with a limit order:

exit_order = self.close(data_min, price = self.target_exit_price[stock], exectype = bt.Order.Limit)

This works as expected. If the strategy takes an entry of 5.783 BTC, this will close that position so it's flat at the target price of self.target_exit_price[stock]

The issue I run into is on closing short positions at a target order. For example, take a short entry at 18000 and buy to close at 17000 limit. In this case, the above self.close() method doesn't work. The price blows right through 17000 and it doesn't close the order.

So here is what happens:

info: 2020-11-08 13:30:00,  raw exit price: 15209.35000  target exit price: 15209.35000
info: 2020-11-08 13:30:00,  Sell order placed at 15513.05 ref: 9
info: 2020-11-08 13:31:00, btc_usd: 9 order executed: price: 15513.05000, value: -102160.36, commm 0.00, stock price: 15535.9
info: 2020-11-08 13:32:00,  btc_usd: stop order placed at 15664.90000 ref: 10
info: 2020-11-08 13:32:00,  short exit order

The strategy takes a short entry at 13:31:00 with a price of 15513.05 with 6.585446163977593 BTC. Next, the buy limit exit profit target order is placed. This is the bit of code for that. A stop order, order #10, is also placed at 15664.90

exit_order = self.buy(data_min, contracts = contracts, price = self.target_exit_price[stock], exectype = bt.Order.Limit)
					
self.orders.append(exit_order)

and the output

info: 2020-11-08 13:32:00, Ref: 11
OrdType: 0
OrdType: Buy
Status: 1
Status: Submitted
Size: 1
Price: 15209.35
Price Limit: None
TrailAmount: None
TrailPercent: None
ExecType: 2
ExecType: Limit
CommInfo: None
End of Session: 737737.9999999999
Info: AutoOrderedDict([('contracts', 6.585446163977593)])
Broker: None
Alive: True
info: 2020-11-08 13:32:00,  btc_usd: target exit order placed at 15209.35000   size:  6.585446163977593   ref: 11

Now some bar-by-bar action. The open trade position is in units of R, referring to the Van Tharp concept.

info: 2020-11-09 00:45:00,  open trade position: 0.09   high: 15511.5    low: 15433.43
info: 2020-11-09 01:00:00,  open trade position: 0.24   high: 15512.47    low: 15474.01
info: 2020-11-09 01:15:00,  open trade position: 0.47   high: 15488.06    low: 15436.1
info: 2020-11-09 01:30:00,  open trade position: 0.65   high: 15480.83    low: 15411.62
info: 2020-11-09 01:45:00,  open trade position: 0.61   high: 15443.84    low: 15397.26
info: 2020-11-09 02:00:00,  open trade position: 0.88   high: 15419.34    low: 15379.14
info: 2020-11-09 02:15:00,  open trade position: 0.66   high: 15429.29    low: 15371.7
info: 2020-11-09 02:30:00,  open trade position: 0.56   high: 15428.22    low: 15373.64
info: 2020-11-09 02:45:00,  open trade position: 0.56   high: 15470.32    low: 15427.53
info: 2020-11-09 03:00:00,  open trade position: 1.16   high: 15434.04    low: 15312.55
info: 2020-11-09 03:15:00,  open trade position: 1.29   high: 15360.57    low: 15296.4
info: 2020-11-09 03:26:00, btc_usd: 11 order executed: price: 15209.35000, value: -15513.05, commm 0.00, stock price: 15200.12

Note at 03:26:00 it executes a partial of the buy order at the limit price. Note it only closing a partial of the position, -15513.05. Let's continue on until the end.

info: 2020-11-09 03:30:00,  open trade position: 2.29   high: 15317.91    low: 15160.58
info: 2020-11-09 03:45:00,  open trade position: 0.74   high: 15403.38    low: 15175.35
info: 2020-11-09 04:00:00,  open trade position: 0.79   high: 15438.82    low: 15380.88
info: 2020-11-09 04:15:00,  open trade position: 0.49   high: 15474.51    low: 15387.11
info: 2020-11-09 04:30:00,  open trade position: 0.59   high: 15474.99    low: 15422.95
info: 2020-11-09 04:45:00,  open trade position: 0.62   high: 15463.21    low: 15418.91
info: 2020-11-09 05:00:00,  open trade position: 0.41   high: 15474.52    low: 15400.54
info: 2020-11-09 05:15:00,  open trade position: 0.26   high: 15490.05    low: 15432.62
info: 2020-11-09 05:30:00,  open trade position: 0.43   high: 15484.33    low: 15444.36
info: 2020-11-09 05:45:00,  open trade position: 0.11   high: 15502.0    low: 15435.98
info: 2020-11-09 06:00:00,  open trade position: 0.24   high: 15502.37    low: 15475.92
info: 2020-11-09 06:15:00,  open trade position: -0.28   high: 15566.52    low: 15467.49
info: 2020-11-09 06:30:00,  open trade position: -0.07   high: 15552.15    low: 15506.67
info: 2020-11-09 06:45:00,  open trade position: -0.43   high: 15588.64    low: 15500.0
info: 2020-11-09 06:50:00, btc_usd: 10 order executed: price: 15664.90000, value: -70982.41, commm 0.00, stock price: 15665.47
info: 2020-11-09 06:50:00, Trade value: 0.00, P/L -544.45, P/L comm: -544.45

Finally, the original stop order #10 is executed and the balance of the position is closed. But the entire position should have closed on order #11, the target exit order.

Am I missing something here with the self.buy() method? If I use self.close() to try and close a short position, it blows through the target price and never executes.

This script works very well on FX using integer contract sizes.

Am I missing something in the self.buy() or self.close() to make this work correctly.

ard9000

Hello Backtrader Community,

I have a strategy that I create manual entries with using a charting application and GUI. I sling entries to BackTrader via ZeroMQ which runs in a separate thread and creates the entries. Once the position is live, the BackTrader script manages the position the stop loss. It works really well using the timer function which is called every second to check or new orders received via ZeroMQ.

I'm running on IQFeed 1 minute data and using our FIX interface we developed for our firm with BackTrader.

The only downside is I have to add the universe of 400 symbols to my script and then break it up into 4 smaller scripts, 100 on each symbols, so that each next() event is proficient. I run the 4 scripts in parallel concurrently and it works really well, just I'm using a lot of CPU and bandwidth.

What I'm looking for is a way to add symbols on an as-needed basis so that I can create orders on symbols that have not been added via cerebro.adddata() when the script starts. This way, I can run a single smaller script and it just adds symbols as it receives entry orders for them. At the end of session, it clears the list and starts fresh the following session. The price/volume bars are not a concern since I have a separate method that pulls in price bars outside of self.datas as a workaround.

For example, if I add data for SPY and QQQ when the script starts and then I receive an order for EWZ, which was not added using .adddata() when the script started, it will of course throw errors for self.getpositionbyname('EWZ) if I try to create an order object on this instance.

Can .adddata() be called during .run() ?

Any other suggestions?

ard9000

I have a strategy that I'm running live with our FIX implementation and noticed there is a difference in the way the stops are executed live and with the default BT broker.

An example:

Buy 1000 shares of AAPL @ 200
Place a stop loss for 1000 shares @ 198
Buy another 1000 shares of AAPL @ 202
Place a stop loss order for the second 1000 shares @ 201

For a long position, the stop order looks like this in our code:

# live trading
stop_order = self.sell(data_min, price=stop_price, exectype=bt.Order.Stop, size=size)

# backtesting 
stop_order = self.close(data_min, price=stop_price, exectype=bt.Order.Stop, size=size)

In this case, size = 1000. For backtesting, if I use self.sell or self.buy, the default BT broker doesn't take it as a stop loss order, it takes it as a stop entry and executes the order immediately. It works fine with self.close instead

In live trading, this works as expected. If I look at live orders on the FIX side, there will be a stop order for 1000 @ 198 and a second order for 1000 @ 201.

In backtesting, if the #4 stop is hit, it sells all 2000 shares and ignores the size= parameter. Is this how this works in the default BT broker or is there an additional parameter required.

ard9000

The test script that demonstrates this with IQFeed with the long IB symbols. If I'm doing something incorrectly here, I'd appreciate what is wrong.


#!/usr/bin/env python
"""
IQFeed live data

IB Brokerage 

"""

import pandas as pd

import argparse
import datetime
import os
import sys

from pytz import timezone
from pandas_market_calendars import get_calendar
from pandas import Series, DataFrame, bdate_range

import backtrader as bt

class Strategy(bt.Strategy):
    """Trading strategy class."""

    params = (
        ('stocks', ('AAPL-STK-SMART-USD','TWTR-STK-SMART-USD','CAT-STK-SMART-USD',)),
        ('timezone', timezone('US/Eastern')),
        ('rsize', 1000),
        ('stdperiod', 30),
        ('debug', True),
        ('info', True),
    )

    def __init__(self):
        bt.Strategy.__init__(self)

        # create IB contract objects

        ibstore = bt.stores.ibstore.IBStore() # to be able to call makecontract API
        self.contracts = [ibstore.makecontract(*stock.split('-')) for stock in self.p.stocks]
        for i, stock in enumerate(self.p.stocks):
            self.datas[i].tradecontract = self.contracts[i]
        
        # initialize parameters

        self.position_sizes = { 'AAPL-STK-SMART-USD': 1200,
                                'TWTR-STK-SMART-USD': 0,
                                'CAT-STK-SMART-USD': 300}
                                
        
        self.stop_orders = {}
        self.df_min = {}
        self.daily = {}
        self.orders = []
        self.entry_price = {}
              
        # set early close days
        calendar = get_calendar('NYSE')
        now = datetime.datetime.now()
        schedule = calendar.schedule(start_date=now - datetime.timedelta(weeks=1),
                                     end_date=now + datetime.timedelta(weeks=200))
        self.early_closes = calendar.early_closes(schedule).index

        self.p.debug = True

    def debug(self, msg):
        if self.p.debug:
            dtime = self.datas[0].datetime
            print('debug: %s %s, %s' % (dtime.date(0, tz=self.p.timezone),
                                        dtime.time(0, tz=self.p.timezone), msg))

    def info(self, msg):
        if self.p.info:
            dtime = self.datas[0].datetime
            print('info: %s %s, %s' % (dtime.date(0, tz=self.p.timezone),
                                       dtime.time(0, tz=self.p.timezone), msg))

    def notify_order(self, order):
        if order.status == order.Completed:
            # calculate cost basis
            stock = order.p.data._name
            value = order.executed.value + order.executed.comm
            entry_price = abs(value / order.executed.size)
            self.info('%s: %s order executed: price: %.2f, value: %.2f, commm %.2f, '
                      'cost basis: %.2f, stock price: %s' %
                      (stock, order.ref, order.executed.price, order.executed.value,
                       order.executed.comm, entry_price, order.p.data[0]))
            self.orders.remove(order)
            
           

    def notify_trade(self, trade):
        if trade.isclosed:

            self.info('Trade value: %.2f, P/L %.2f, P/L comm: %.2f' %
                      (trade.value, trade.pnl, trade.pnlcomm ))
           
    def eod(self):
        """
        Calculate time of eod actions.
        """
        if self.data0.datetime.date() in self.early_closes:
            return datetime.time(12, 30)
        else:
            return datetime.time(15, 54)


    def next(self):
        """Main processing is happening here. This method is called for every bar."""
    
       # check to make sure all data has been accumulated before calling next

        ctime = self.data0.datetime.time(0, tz=self.p.timezone)
        cdate = self.data0.datetime.date(0, tz=self.p.timezone)
        cdt = self.data0.datetime.datetime(0, tz=self.p.timezone)
        tz = self.p.timezone

        # skip bars from history
        if datetime.datetime.now(tz=tz) - tz.localize(self.data0.datetime.datetime()) >= datetime.timedelta(minutes=1):
            return

        # check to make sure all data has been accumulated before calling next
        
        if len(set(data.datetime.datetime() for data in self.datas )) > 1:                                                                             
            # skip processing if all minute bars not arrived yet                                                                                                                     
            return

        # don't process bars after 16:00 or before 9:30
        
        for data in self.datas:
            if data.datetime.time(0, tz=self.p.timezone) < datetime.time(9,30) or self.data.datetime.time(0, tz=self.p.timezone) > datetime.time(16,0,0):
                return

                    
        for i, stock in enumerate(self.p.stocks):
            
           # get position data - first method using getdatabyname(stock)
             
            data_min = self.datas[i]
            position = self.getposition(data_min)

           # if there is no position and it's not set to zero, create a short order for it

            if not position.size and self.position_sizes[stock] != 0:
               order = self.sell(data_min, size=self.position_sizes[stock])
               self.orders.append(order)
               self.stop_orders[stock] = ''

           # second position method

            data_min2 = self.getdatabyname(stock.split("-")[0])
            position2 = self.getpositionbyname(stock.split("-")[0])

            position_size2 = position2.size
            entry_price2 = position2.price

            self.info(" \n getpositionbyname method %s position size: %s entry price: %s" %(stock, position_size2, entry_price2))

           # demonstrate stop orders not being set

            if position.size != 0 and position.price:

                self.entry_price[stock] = position.price

                self.info("%s position size: %s entry price: %s current close: %s" %(stock, position.size, position.price, data_min.close[0]))

                if not self.stop_orders.get(stock) and self.entry_price[stock]:
                    stop_price = self.entry_price[stock] + .3
                    stop_order = self.close(data_min, price=stop_price, exectype=bt.Order.Stop)
                    self.stop_orders[stock] = stop_order
                    self.orders.append(stop_order)
                    self.info(" %s: stop order sent at %.2f" %(stock,stop_price))

                

def parse_args():
    parser = argparse.ArgumentParser(
                 formatter_class=argparse.ArgumentDefaultsHelpFormatter,
                 description='Live strategy run on Interactive Brokers')

    parser.add_argument('--host', default='127.0.0.1',
                        required=False, action='store',
                        help='Host for the Interactive Brokers TWS Connection')

    parser.add_argument('--qcheck', default=0.5, type=float,
                        required=False, action='store',
                        help=('Timeout for periodic '
                              'notification/resampling/replaying check'))

    parser.add_argument('--port', default=7497, type=int,
                        required=False, action='store',
                        help='Port for the Interactive Brokers TWS Connection')

    parser.add_argument('--clientId', default=None, type=int,
                        required=False, action='store',
                        help='Client Id to connect to TWS (default: random)')

    parser.add_argument('--reconnect', default=3, type=int,
                        required=False, action='store',
                        help='Number of recconnection attempts to TWS')

    parser.add_argument('--timeout', default=180, type=float,
                        required=False, action='store',
                        help='Timeout between reconnection attempts to TWS')

    parser.add_argument('--debug',
                        required=False, action='store_true',
                        help='Display all info received form IB')

    return parser.parse_args()
                
def main(argv):
    """Entry point."""
    args = parse_args()

    # Create a cerebro entity
    cerebro = bt.Cerebro(maxcpus=1, oldsync=False)

    # Set broker
    broker = bt.brokers.IBBroker(host=args.host, port=args.port,
                                 clientId=args.clientId, reconnect=args.reconnect,
                                 timeout=args.timeout, _debug=args.debug)
    cerebro.setbroker(broker)

    # Create store
    store = bt.stores.IQFeedStore(reconnect=args.reconnect,
                                  timeout=args.timeout,
                                  debug=args.debug)
    
    # Add data feeds
    
    for stock in Strategy.params.stocks:
        ticker = stock.split('-')[0]

        hist_start_date = bdate_range(end=datetime.datetime.now(), periods=Strategy.params.stdperiod + 2)[0].to_pydatetime()
        data = bt.feeds.IQFeed(dataname=ticker, name=ticker,
                               tz=Strategy.params.timezone,
                               timeframe=bt.TimeFrame.Minutes,
                               sessionstart=datetime.time(hour=9, minute=30),
                               sessionend=datetime.time(hour=16, minute=00, second=59),
                               fromdate=hist_start_date)
        cerebro.adddata(data)

    # Print out the starting conditions
    print 'Starting Portfolio Value: %.2f' % cerebro.broker.getvalue()

    # Add a strategy
    cerebro.addstrategy(Strategy)

    # Run over everything
    cerebro.run()

if __name__ == '__main__':
    sys.exit(main(sys.argv))

ard9000

I'm sorry for the 'more bugs' headline, I agree it was harsh and not productive to resolving the issue.

I am a licensed professional trader in the US, I'm a partner at a prop firm.I really love the platform and am championing bringing it into our firm as our python platform. We've been using it for the past 18 months to develop algos with and are now implementing it for live trading. We're using IB to test with as we build a FIX broker interface to work with Backtrader and our servers.

My code does indeed look like that. We had Ed Bartosh integrate IQFeed into Backtrader for us. Ed also integrated CCXT into the platform for crypto trading, both of which we are giving to the Backtrader community for (hopefully) future inclusion in the platform. Both are available from his git branch. We've been debugging the IQFeed implementation for months in live trading, I believe it's production worthy.

So we don't have to deal with using the IB symbol in our code 'AAPL-STK-SMART-USD' I run the code like this:


 params = (
        ('stocks', ('AAPL','TWTR','VIX.XO',)),
        ('tradable', ('AAPL','TWTR',)),
        ('timezone', timezone('US/Eastern')),)

for i, stock in enumerate(self.p.stocks):
            if stock in self.p.tradable:
                self.contracts.append(ibstore.makecontract(stock,'STK','SMART','USD'))
                self.datas[i].tradecontract = self.contracts[i]

In main, I setup the symbols this way:

# Set broker
    broker = bt.brokers.IBBroker(host=args.host, port=args.port,
                                 clientId=args.clientId, reconnect=args.reconnect,
                                 timeout=args.timeout, _debug=args.debug)
    cerebro.setbroker(broker)

    # Create store
    store = bt.stores.IQFeedStore(reconnect=args.reconnect,
                                  timeout=args.timeout,
                                  debug=args.debug)
    
    # Add data feeds
    
    for stock in Strategy.params.stocks:
        ticker = stock.split('-')[0]

        hist_start_date = bdate_range(end=datetime.datetime.now(), periods=Strategy.params.stdperiod + 2)[0].to_pydatetime()
        data = bt.feeds.IQFeed(dataname=ticker, name=ticker,
                               tz=Strategy.params.timezone,
                               timeframe=bt.TimeFrame.Minutes,
                               sessionstart=datetime.time(hour=9, minute=30),
                               sessionend=datetime.time(hour=16, minute=00, second=59),
                               fromdate=hist_start_date)
        cerebro.adddata(data)

Doing it this way, you can see we have the ticker = stock.split('-')[0] left over from when we were using the long IB symbols in self.p.stocks.

We've made a test script to verify the bugs in the position.size and position.price when multiple positions are open in the same script. The other problem is the stop loss orders, they are intermittent.

 stop_order = self.close(data_min, price=stop_price, exectype=bt.Order.Stop)
 self.stop_orders[stock] = stop_order
 self.orders.append(stop_order)

If the script is run 10 times, sometimes the stop orders will appear in IB TWS, other times they won't. There seems to be no reproducible pattern as to why the sometimes do and don't appear. All other orders work fine.

Since this platform is free (and I really like it) community driven and to encourage growth of the platform, we're going to fix these now and give them to the community. Even though we will never trade live with IB. If you can give Ed some help when he needs it to expedite fixing these, it would be very helpful for everybody.

ard9000

@ard9000

Bump.

My hopes to this being resolved are fading quick. It doesn't appear, based on this and my other post about the getposition() bugs in live IB trading, that anyone is using BT for live equities trading.

ard9000

I have a strategy that I'm running with my IB paper trading account. If I'm running three symbols, says AAPL, JNJ, CSCO and the strategy status is:

AAPL long 1200 shares
JNJ flat no position
CSCO long 800 shares

When live trading with IB, if my code looks like this:

data = self.datas[i]
position = getposition(data)

entry_price = position.price
position_size = position.size

Let's say I'm pulling data for AAPL this way. For AAPL, it returns:

position.size = 2000 and
position.entry_price = the correct entry price

The entry price works correctly, but the position.size returns the aggregate of all open positions. However the result gets stranger when using a different method. If I use:

data = getdatabyname('AAPL')
position = getposition(data)

entry_price = position.price
position_size = position.size

The result of entry_price is an average across all symbols and position_size is still the aggregate of all open positions. The same thing happens if I use:

data = self.datas[i]
position = getpositionbyname('AAPL')

entry_price = position.price
position_size = position.size

These all work fine in backtesting. I verified that [i] is the correct position in datas[i]. Is there something I'm missing here?

ard9000

The result is the same if I use:

stop_order = self.close(data_min, price=stop_price, exectype=bt.Order.Stop)

stop_order = self.buy(data_min, price=stop_price, exectype=bt.Order.Stop)

stop_order = self.sell(data_min, price=stop_price, exectype=bt.Order.Stop)

ard9000

I have a strategy that I'm implementing using the IB broker to interface with for my test account. Everything works great except stop orders. In my backtest strategy I have:

stop_order = self.close(data_min, price=stop_price, exectype=bt.Order.Stop)
self.orders.append(stop_order)

Where data_min is the minute data feed I'm using. When stop orders are placed this way using exectype=bt.Order.Stop, there is no stop loss order created. Either with IB or within the strategy itself, if the price moves through the stop price, it never exits.

All of the other entries and exits with BT work great with IB.

Is there a specific exectype for IB market stop loss orders?

Posts made by ard9000