Hi Han,

If you're trying to rebalance and maintain a target position in your portfolio, then your first option is better. In the second option, you'll incur unnecessary commission costs and the portfolio positions object will be empty when you loop through it.

Here's an example of a rebalance live trading algo, it's the one we're running on our Interactive Brokers account: https://www.quantopian.com/posts/rebalance-algo-9-sector-etfs

Keep in mind that the order_target methods make their calculation for the target amounts based on filled orders. They don't take into consideration open orders, so you will need to add this guard. You can use the code from the algo above or simply use:

handle_data(contexrt,data):  
  if get_open_orders:  
    return  

Chiming in here this is the mechanism I use to try and keep leverage <= 1.0:

eligible = []  
# perform your logic to pick the eligible securities and add them here  
for stock in data:  
    if (data[stock].SpecialEntryFactorIsTrueHere):  
        eligible.append(stock)

positions = context.portfolio.positions  
openPositions = [stock for stock in positions if positions[stock].amount > 0 and stock not in eligible]  
eligible += openPositions  
eligibleCount = float(len(eligible))  
for stock in eligible:  
    if (get_open_orders(stock)):  
        continue  
    order_target_percent(stock, 1.0 / eligibleCount)  
    if (context.portfolio.positions[stock].amount == 0.0):  
        print("  Entry Long  {0:<5} @ {1:>6.2f}".format(  
                stock.symbol, data[stock].close_price))  

@Market Tech, in the for loop it seems the sell orders can be executed the last (stocks with amount>0 are appended to eligible). I am wondering why this code keeps leverage under 1.

@Han C. Well, the intent, and maybe I've failed in my execution of the intent, was

• to perform the selection of any new long entries,
• add to this list of new entries existing long positions which were not already (re)selected for entry,
• use this composite number of open positions + new positions to determine the proper divisor for the % entries,
• perform a crude open orders test which might compound the intended position of a security.
• enter each leg or readjust an open leg given the new % for each.

It seems to work in the strats I've used it within. It's long only which is limiting. And pretty much assumes that there are no open orders, but will side with caution if there is.

One can only try it to see if my assumptions are correct or bogus.