Can I have a VWAP crossover?

I have been playing with this

# For this example, we're going to write a simple momentum script. When the
# stock goes up quickly, we're going to buy; when it goes down quickly, we're
# going to sell. Hopefully we'll ride the waves.

# To run an algorithm in Quantopian, you need two functions: initialize and  
# handle_data

from quantopian.algorithm import attach_pipeline, pipeline_output
from quantopian.pipeline import Pipeline
from quantopian.pipeline.data.builtin import USEquityPricing
from quantopian.pipeline.factors import VWAP

def initialize(context):
# This initialize function sets any data or variables that you'll use in
# your algorithm. For instance, you'll want to define the security (or
# securities) you want to backtest. You'll also want to define any
# parameters or values you're going to use.

# In our example, we're looking at Apple.  If you re-type this line  
# yourself, you'll see the auto-complete that is available for the  
# security ID.  
context.aapl = sid(24)  

# In these two lines, we set the maximum and minimum we want our algorithm  
# to go long or short our security.  You don't have to set limits like this  
# when you write an algorithm, but it's good practice.  
context.max_notional = 1000000.1  
context.min_notional = -1000000.0  

# We are going to use pipeline to calculate a 3 day VWAP for all securities.  
pipe = Pipeline()  
attach_pipeline(pipe, 'vwap_calc')  


VWAP_3 = VWAP(window_length=3)  
pipe.add(VWAP_3, 'vwap')  

#We will schedule our algo to run daily, 5 minutes after the market opens  
schedule_function(rebalance,  
                  date_rule=date_rules.every_day(),  
                  time_rule=time_rules.market_open(minutes=5),  
                  half_days=True)

def before_trading_start(context, data):
# Our pipeline output includes all securities in the universe.
context.pipe_output = pipeline_output('vwap_calc')

# We narrow it down to just the security we are interesting in.  
context.pipe_output = context.pipe_output[context.pipe_output.index == context.aapl]

def rebalance(context,data):
# Here we're getting the volume-weighted-average-price of the security
# defined above, in the context.aapl variable, from the pipeline output.
vwap = context.pipe_output.iloc[0]['vwap']

# We need a variable for the current price of the security to compare to  
# the average.  
price = data.current(context.aapl, 'price')  

# Another powerful built-in feature of the Quantopian backtester is the  
# portfolio object.  The portfolio ojbect tracks your positions, cash,  
# cost basis of specific holdings, and more.  In this line, we calculate  
# how long or short our position is at this minute.  
notional = context.portfolio.positions[context.aapl].amount * price  

# This is the meat of the algorithm.  
# If the price of the security is .5% less than the 3-day volume  
# weighted average price AND we haven't reached our maximum short,  
# then we call the order command and sell 100 shares.  
#Similarly, if the stock is .5% higher than the 3-day average AND  
# we haven't reached our maximum long, then we call the order command  
# and buy 100 shares.  
if price < vwap * 0.995 and  price > vwap * 0.995:  
    order(context.aapl,-100)  
elif price > vwap * 1.005 and notional < context.max_notional:  
    order(context.aapl,+100)