Have a look at a recent thread on trading different time intervals. I posted some code that breaks up the day into "opening", "5 minute chunks", and "closing".

https://www.quantopian.com/posts/how-to-create-different-time-intervals

You should be able to modify that to suit your needs. Note that it doesn't have any awareness of when the market will close early (e.g. the day before a holiday).

Also, numerous people have requested the official implementation of market-on-close orders, so I expect they will eventually implement them!

So, you want to use minute data, but only for the current day. If I understand correctly, you want to store past days' closing prices but work with the current days' minute prices. One way to do this is to make a dictionary that links days to the last price recorded during that day, like this. This is meant to be run in minute mode. With this, you can trigger an order the minute whatever event involving the average happens.

# Insert most recent price for each day into the dictionary  
context.past_prices[get_datetime().date()] = data[context.security].price

# If the dictionary's length is over what we want to average over  
if len(context.past_prices) > 10:  
    # Find and remove the oldest entry  
    last = sorted(context.past_prices.items(), key=lambda t: t[0])[0]  
    del context.past_prices[last[0]]

# The 10-day moving average including most recent price from today  
mavg = sum(context.past_prices.values())/len(context.past_prices)

log.info(mavg)  

@Gus, I think you could achieve a rolling window of daily closing prices just a tad easier using a deque.

Also, when working in minute-mode it's important to recognize that data[stock].price refers to the current minute bar, not yesterday's close.

from collections import deque  
import numpy as np

# in initialize()

# initialize deque for 10 days of daily close prices  
context.past_prices = deque( [], maxlen=10 )

# remember price from one minute bar to the next  
context.last_price = None

# remember the date of the price we remembered  
context.last_date = None

# in handle_data()

# check for first minute bar of the day  
if get_datetime().date() <> context.last_date and context.last_price <> None:  
    # Insert most recent closing price for each day into the deque  
    context.past_prices.appendleft( context.last_price )

# update remembered price and date  
context.last_price = data[context.security].price  
context.last_date = get_datetime().date()

# If the deque's length is equal what we want to average over  
if len(context.past_prices) == 10:  

    # The 10-day moving average  
    mavg = np.mean(context.past_prices)

    log.info(mavg)  

Interesting Dennis, deques seem really useful, I hadn't heard of them before. BTW, I insert the most recent price into the dict with data[stock].price for a reason. It just overwrites the most recent one every minute until the new day begins when it starts a new dict entry. That way when it stops overwriting the past day, we have effectively stored that last day's closing price, and can store and work it with other days prices and the current day's current price.

@Gus, I missed that implication. Your solution should work just as well.