Hey Romi,

You can use the context object to store data in one bar and use it in the next. context is passed to handle_data on every iteration.

Best,
Ryan

Thanks a lot Ryan!

Hi Romi,

I just posted a similar example code snippet to another thread and realized it was applicable here as well. You are correct that history() currently only supports grabbing daily trailing prices. Here is one way to store up 1 trailing day (390 bars) of minutely data. Do note that while history will populate the historical window with data back prior to the backtest start time, this method is an accumulator and will start off empty, adding bars each minute until the maximum length of 390 minutes is reached.

Hope this is helpful. Best wishes, Jess

from collections import defaultdict, deque  
from functools import partial  
import numpy as np


def initialize(context):  
    context.stock = sid(24)  
    context.prices  = defaultdict(partial(deque, maxlen=390)) 

# Will be called on every trade event for the securities you specify.  
def handle_data(context, data):  

    price = data[context.stock].price  
    context.prices[context.stock].append(price)  
    stock_series = np.array(context.prices[context.stock])  
    record(number_of_points_stored = len(stock_series))  

Hi Jessica - thank you very much for sharing this example. That's exactly what I'm looking to do. Very helpful; much appreciated!

@Romi (and Jessica) keep in mind that You must limit the size of your array via something like

del stock_series[0:maxLength]  

Otherwise the Quantopian simulation run will crash over a multiple year run. Run out of memory I'm guessing. (This happened to me in my framework until I added the truncation logic)
you can see my (complex) framework here: https://github.com/Novaleaf/QuantShim

EDIT: oh i see that the 'defaultdict' line has that occur automatically. Just keep in mind that you always do this for normal arrays too!!!

This seems to work and you get a DataFrame to work with. Deque is probably more efficient, but I'm not really sure.

class DataCache:  
    def __init__(self, bars=390):  
        self.bars = bars  
        self._data = {}  
        self.df = None  
    def append(self, data):  
        dt = get_datetime()  
        bar = pd.Series({i: data[i].price for i in data.keys()})  
        self._data[dt] = bar  
        self.df = pd.DataFrame(self._data).T.tail(self.bars)  
        self._data = self.df.T.to_dict()

Here's another approach that uses the minute-bar data returned by history to build up a dataframe:

import pandas as pd

window = 5

def initialize(context):  
    context.stocks = [ sid(19662), # XLY Consumer Discrectionary SPDR Fund  
                       sid(19656), # XLF Financial SPDR Fund  
                       sid(19658), # XLK Technology SPDR Fund  
                       sid(19655), # XLE Energy SPDR Fund  
                       sid(19661), # XLV Health Care SPRD Fund  
                       sid(19657), # XLI Industrial SPDR Fund  
                       sid(19659), # XLP Consumer Staples SPDR Fund  
                       sid(19654), # XLB Materials SPDR Fund  
                       sid(19660)] # XLU Utilities SPRD Fund  
    context.prices = pd.DataFrame()  
def handle_data(context, data):  
    prices = history(1,'1d','price')  
    context.prices = context.prices.append(prices)  
    context.prices = context.prices.tail(window)  
    if len(context.prices) < window:  
        return  
    print context.prices  

[EDIT] Please note the help page documentation on history if adapting this code to include volumes (e.g. computation of VWAP). Although history returns price data for the current minute, the volume is cumulative over the current trading day.

I saw you are new to Python so I thought I'd toss it in an example so you can see how it works. This one keeps just the last 25 bars.