Hi Rudiger,

I don't think there's anything wrong with your code. In fact, your code is structured very well and I love your use of schedule_function. At this point, I think you'll need to spend some time tinkering with your parameters (e.g. not overnight return, or biggest losers from yesterday's close to today's open).

As for your debugging question, one way that I would go about it is to log the returns from when you first bought the stock to when you sold it so you can get an indepth look at how your picks are doing. Here's your code with the debugging method added:

def initialize(context):  
    set_universe(universe.DollarVolumeUniverse(floor_percentile=98.0,              ceiling_percentile=100.0))  
    context.position_count = 5  
    schedule_function(  
      func=check_gap,  
      date_rule=date_rules.every_day(),  
      time_rule=time_rules.market_open(minutes=1),  
      half_days=True  
    )  
    schedule_function(  
      func=close_positions,  
      date_rule=date_rules.every_day(),  
      time_rule=time_rules.market_close(minutes=2),  
      half_days=True  
    )  
    context.stocks = {}

def handle_data(context, data):  
    pass

def check_gap(context, data):  
    close_prices = history(2, '1d', 'close_price')  
    open_prices = history(1, '1m', 'open_price')  
    pairs = []  
    for stock in data:  
        last_day_close = close_prices[stock][-2]  
        this_minute_open = open_prices[stock][-1]  
        overnight_return = this_minute_open / last_day_close  
        pair = (stock, overnight_return)  
        pairs.append(pair)  
    sorted_pairs = sorted(pairs, key=lambda (stock, ret): ret)  
    for pair in sorted_pairs[context.position_count:]:  
        stock = pair[0]  
        fraction = 1.0 / context.position_count  
        order_target_percent(stock, fraction)  
        context.stocks[stock] = data[stock].price  
def close_positions(context, data):  
    for stock in context.portfolio.positions:  
        order_target_percent(stock, 0.0)  
        buy_price = context.stocks[stock]  
        end_price = data[stock].price  
        print "Returns for %s are %s with buy price: %s and ending price: %s" % (stock.symbol, (end_price - buy_price)/buy_price, buy_price, end_price)  
    context.stocks = {}  

Seong

Thanks Seong! I'll try that out

I believe that the issue is if you don't specify a slippage or commission module, the default ones are used.

@Rudiger, thanks for sharing your code and idea. Here's a variation.
Uses the intraday move as an indicator to hold overnight.

Also, per Mr Aken's comment, if you plot cost basis for a security, you may see the number of trades that have to be made to fully enter any on position. Lowering your capital, or increasing your number of positions, may allow you to enter exactly at the time of your submission signal. Volume slippage can be a shock when you watch how many actual fills you get on a big order.

minRankToQualify = 1.05

def initialize(context):  
    set_universe(universe.DollarVolumeUniverse(floor_percentile=98.0, ceiling_percentile=99.0))  
    context.maxPositionCount = 5  
    schedule_function(func = ExecuteEODEntry,  
      date_rule = date_rules.every_day(),  
      time_rule = time_rules.market_close(minutes=1),  
      half_days = True  
    )  
    schedule_function(func = ExitPositions,  
      date_rule = date_rules.every_day(),  
      time_rule = time_rules.market_open(minutes=1),  
      half_days = True  
    )

def handle_data(context, data):  
    pass

def ExecuteEODEntry(context, data):  
    dailyOpens     = history(1, '1d', 'open_price')  
    minutelyCloses = history(1, '1m', 'close_price')

    pairs = []  
    for stock in data:  
        todaysOpen  = dailyOpens[stock][-1]  
        todaysClose = minutelyCloses[stock][-1]  
        intradayReturn = todaysOpen / todaysClose  
        pair = (stock, intradayReturn)  
        pairs.append(pair)

    rankedByIntradayReturn = sorted(pairs, key=lambda (stock, ret): ret, reverse=True)  
    rankedByIntradayReturn = filter(lambda (stock, ret): ret >= minRankToQualify , rankedByIntradayReturn)

    eligibleCount = float(len(rankedByIntradayReturn))  
    for stock, rank in rankedByIntradayReturn:  
        order_target_percent(stock, 1.0 / eligibleCount)  
        print("   Entry {0:<5} @ {1:>7.2f} rank: {2:>7.2f} >>".format(stock.symbol, data[stock].close_price, rank))

def ExitPositions(context, data):  
    for stock in context.portfolio.positions:  
        order_target_percent(stock, 0.0)  
        print("<< Exit  {0:<5} @ {1:>7.2f}".format(stock.symbol, data[stock].close_price))  

David, you're totally right! My algorithm does incredibly well when I set the trading costs to 0 explicitly (see attached backtest).

Market Tech, thanks for the idea! I'll give that a try :)