Dear Zipline Maintainers,

Before I tell you about my issue, let me describe my environment:

Environment

Now that you know a little about me, let me tell you about the issue I am
having:

Description of Issue

• What did you expect to happen?

Using daily frequency data, I expected a limit buy order to fill on the current bar at the limit price if the limit price is above the low price - or possibly at the open price if the open price gap is below the limit price.

• What happened instead?

The only condition for which a limit buy order gets filled seems to be if the limit price is greater than the close price of the next bar. If that condition occurs then the buy order is filled on the next bar at the close price of the next bar. If that condition does not occur, the limit buy order does not get filled even if limit price falls within the open-low-close prices of the current bar (or of the next bar).

Here is how you can reproduce this issue on your machine:

Reproduction Steps

1. Create a bundle with daily data for some symbol, such as SPY.
2. Create and run some test code in a notebook similar to the code below.

`
from zipline import run_algorithm
from zipline.api import order_target_percent, symbol, schedule_function, date_rules, time_rules
from zipline.finance.execution import MarketOrder, LimitOrder
from zipline.finance.slippage import FixedSlippage, NoSlippage, SlippageModel
from datetime import datetime
import pytz
import pyfolio as pf
import numpy as np

class InstantSlippage(SlippageModel):
# See #1844 (comment)
# See also #2364 (comment)
# Instant fill on the current bar at the current bar close or open price is not possible with daily data.
# By default market orders are filled on the next bar at the next bar's close price.
# With a custom slippage model we can't change which bar the order is filled, but we can change the fill price.
# With this model - we can set the fill price to be the prior day close or alternatively the current day open.

def process_order(self, data, order):
    # Use price from previous bar
    price = data.history(order.sid, 'price', 2, '1d')[0]
    
    # Alternative: Use current bar's open, instead of close
    #price = data.current(order.sid, 'open')

    return (price, order.amount)

def initialize(context):

context.set_slippage(NoSlippage())
#context.set_slippage(InstantSlippage())  # this works for market ordeers
#context.set_slippage(LimitBuySlippage()) # this does not work for limit orders
    
# Schedule the trading routine
# Note time_rules seem to be ignored with daily frequency data.
schedule_function(trade, date_rules.every_day(), time_rules.market_close()) 
#schedule_function(trade, date_rules.every_day(), time_rules.market_open()) 

# market orders are executing at next day close + slippage regardless of the time rules!
# Limit orders are filled on the next bar only if the limit price is greater than the close of the next bar!
# See https://github.com/quantopian/zipline/issues/2217#issue-334055304

# Which stock to trade
context.spy = symbol('SPY')

def trade(context, data):

# Trade execution with daily data is problematic
    
# Market orders will fill by default at the close price of the next day (assuming no slippage).
# We can use "InstantSlippage" above to set the price of the fill (if not the day of the fill).
#order_target_percent(context.spy, 1.0, style=MarketOrder())

# Limit orders will fill at the close of the next day only if  limit price > next day close price.
order_target_percent(context.spy, 1.0, style=LimitOrder(limit_price=331.8))  # this order gets filled
#order_target_percent(context.spy, 1.0, style=LimitOrder(limit_price=331.4))  # this order does not get filled

open_price = data.history(context.spy, 'open', 1, '1d').iloc[-1]
high_price = data.history(context.spy, 'high', 1, '1d').iloc[-1]
low_price = data.history(context.spy, 'low', 1, '1d').iloc[-1]
close_price = data.history(context.spy, 'close', 1, '1d').iloc[-1]

print(data.history(context.spy, 'close', 1, '1d').index)
print('open = {}'.format(open_price))
print('high = {}'.format(high_price))
print('low= {}'.format(low_price))
print('close = {}'.format(close_price))
print()

def analyze(context, perf):
# Use PyFolio to generate a performance report
returns, positions, transactions = pf.utils.extract_rets_pos_txn_from_zipline(perf)

start = datetime(2020, 1, 22, tzinfo=pytz.UTC)
end = datetime(2020, 1, 23, tzinfo=pytz.UTC)

result = run_algorithm(
start=start,
end=end,
initialize=initialize,
analyze=analyze,
capital_base=10000,
data_frequency = 'daily',
bundle='rising_assets_data'
)

returns, positions, transactions = pf.utils.extract_rets_pos_txn_from_zipline(result)
transactions.tail()`

What steps have you taken to resolve this already?

I tried to create a custom slippage model for limit buys like the code below, but it did not work.
`class LimitBuySlippage(SlippageModel):

def process_order(self, data, order):
   
    limit_price = order.limit
    #open_price = data.current(order.sid, 'open')
    #low_price = data.current(order.sid, 'low')
    open_price = data.history(order.sid, 'open', 2, '1d')[0]
    low_price = data.history(order.sid, 'low', 2, '1d')[0]
    
    price = np.where(open_price<limit_price,open_price,np.where(low_price<limit_price,limit_price,np.nan))

    return (price, order.amount)`

...

Anything else?

I realize it may not be possible to get instant (same day) limit order fills on the current bar with the existing code base. However if there could be a way to create a custom slippage model (similar to the excellent InstantSlippage model #1844 (comment) for market orders) to achieve execution on the next bar at the resulting limit order fill price (if limit is triggered on the current bar), that would be great!
...

Sincerely,
quantSystemDev