Which 'specific days' do you want to trade? Will this be a hard coded list, the first of each month, the day after earnings have been announced, or something else?

Thanks, Dan. It will be a hard-coded list with no regular pattern.

I'm relatively new to this, but I've been exploring the use of get_trading_days from the zipline.utils.tradingcalendar to get trading day offsets.

from zipline.utils import tradingcalendar
from zipline.utils.tradingcalendar import get_trading_days

 date_range = get_trading_days(datetime.datetime(2017,3,14),datetime.datetime(2017,3,21))        #Tuesday thru Tuesday  
 print(date_range[4])      #correctly produces the following Monday

A problem that remains is that get_trading_days requires parameters which datetime.datetime produces. Using datetime.date throws an error:
AttributeError: 'datetime.date' object has no attribute 'date'

If I use this date_range[4] in my algorithm, however, it never matches, probably due to the time portion of the response.

if get_datetime().date() == date_range[4]:  
    order_target_percent(stock,1.0)

How can I massage date_range[4] into a form which can successfully match with the get_datetime().date() response?
If I can accomplish this, I think I can make the algorithm work with trading day offsets.

Here is half a solution. In your initialize function put this

    # enter a list of rebalance dates as strings  
    date_str_list = ['1-1-2020',  
                     '1-3-2020',  
                     '1-5-2020',  
                     '1-7-2020',  
                     '1-15-2020',  
                     ]  
    # create a list of dates  
    context.date_list = [pd.Timestamp(date).date() for date in date_str_list]

Then, in rebalance check if the current trading day is in the list.

    today = algo.get_datetime().date()

    if today not in context.date_list:  
        # return and do nothing  
        log.info(' NOT rebalancing on {}'.format(today))  
        return  

This will check for dates in the list but not do the offset as requested. I'm looking into how to potentially use the trading calendar for that.

Hope this is a start.

Thanks again for your help, Dan. I persevered with altering the format produced by get_trading days, and was finally successful.
Here's the entire algorithm for buying and selling on fixed specified dates with independent buying and selling trading days of delay up to 5 days.
It seems to produce correct trading (not calendar) day delays. There's probably a more elegant way of accomplishing it, but this was the best I could do.

-----------------------------------------------------------------------

stock = symbol('SPY')

-----------------------------------------------------------------------

import datetime
from zipline.utils import tradingcalendar
from zipline.utils.tradingcalendar import get_trading_days

def initialize(context):
context.buy_delay = 3
context.sell_delay = 4
schedule_function(trade,date_rules.every_day(),time_rules.market_open(minutes = 1))

def before_trading_start(context, data):
pass

def trade(context,data):
buy_range = get_trading_days(datetime.datetime(2017,3,14),datetime.datetime(2017,3,21))

if str(get_datetime().date()) == str(buy_range[context.buy_delay])[0:10]:  
    order_target_percent(stock,1.0)


sell_range = get_trading_days(datetime.datetime(2017,3,21),datetime.datetime(2017,3,28))

if str(get_datetime().date()) == str(sell_range[context.sell_delay])[0:10]:  
    order_target_percent(stock,0.0)