Scheduling & Controls

Use scheduled functions or calendar gates when your strategy should act at specific times instead of on every bar. Use controls to enforce risk rules before an order is accepted.

Calendar gates

The simplest way to rebalance weekly or monthly is a gate at the top of handle_data:

async def handle_data(context, data):
    if not context.is_month_start():     # or context.is_week_start()
        return
    ...

Both read the simulation’s trading calendar, so holidays are handled without date arithmetic. They are plain calls, not awaited.

Scheduling callbacks

`context.schedule_function(func, date_rule=None, time_rule=None, half_days=True, calendar=None)`

from ziplime.finance.execution import MarketOrder
from ziplime.utils.events import date_rules, time_rules


async def initialize(context):
    context.asset = await context.symbol("AAPL")
    context.schedule_function(
        rebalance,
        date_rule=date_rules.week_start(),
        time_rule=time_rules.market_open(minutes=30),
    )


async def rebalance(context, data):
    await context.order_target_percent(context.asset, 1.0, style=MarketOrder())

date_rule defaults to every trading day.
time_rule works at any intraday emission rate — 1 minute, 5 minutes, an hour. On a daily run there is one bar per session, so the time rule is ignored.
Pass the time rule by keyword. A time rule in the date_rule position is accepted with a warning.

Date rules

from ziplime.utils.events import date_rules

Rule	Meaning
`date_rules.every_day()`	Every trading day
`date_rules.week_start(days_offset=0)`	Nth trading day of each week
`date_rules.week_end(days_offset=0)`	N trading days before week end
`date_rules.month_start(days_offset=0)`	Nth trading day of each month
`date_rules.month_end(days_offset=0)`	N trading days before month end

Time rules

from ziplime.utils.events import time_rules

Rule	Meaning
`time_rules.market_open(hours=0, minutes=30)`	After market open
`time_rules.market_close(minutes=15)`	Before market close
`time_rules.every_minute()`	Every bar of an intraday run

Offsets must be between 1 minute and 12 hours.

Calendars

schedule_function uses the simulation’s trading calendar unless you pass calendar=calendars.US_EQUITIES or calendar=calendars.US_FUTURES:

from ziplime.utils.events import calendars

context.schedule_function(
    rebalance,
    date_rule=date_rules.month_end(),
    time_rule=time_rules.market_close(minutes=30),
    calendar=calendars.US_EQUITIES,
)

Any other value raises. For runs that mix venues, see Venues & Calendars.

Which hook for what

Hook	Can place orders?	Define as	Common use
`before_trading_start`	No	`async def`	Prepare the universe, reset daily state, read pipeline output
Scheduled callback	Yes	`async def`	Rebalance, exit, risk reduction at a set time
`handle_data`	Yes	`async def`	Per-bar trading logic

Trading controls

Controls are configured in initialize and checked against every order before it is placed. Since 2.10.3 they are enforced — earlier versions accepted the limits and enforced none.

async def initialize(context):
    context.set_long_only()
    context.set_max_leverage(1.5)
    context.set_max_position_size(asset=None, max_shares=1_000, max_notional=50_000)
    context.set_max_order_size(asset=None, max_shares=500, max_notional=25_000)
    context.set_max_order_count(10)

Control	Limits
`set_long_only(on_error="fail")`	No order may take a position short
`set_max_leverage(max_leverage)`	Account leverage. `run_simulation(max_leverage=...)` and `ziplime run --max-leverage` register it too (default 1.0)
`set_min_leverage(min_leverage, grace_period)`	Minimum leverage after a grace period
`set_max_position_size(asset=None, max_shares=None, max_notional=None, on_error="fail")`	Absolute position size, per asset or globally with `asset=None`
`set_max_order_size(asset=None, max_shares=None, max_notional=None, on_error="fail")`	Size of any single order
`set_max_order_count(max_count, on_error="fail")`	Orders per day
`set_asset_restrictions(restrictions, on_error="fail")`	A restricted list

Error behavior

With on_error="fail" (the default) a violating order raises TradingControlViolation. With on_error="log" the violation is logged as an error and the order goes through.

Asset restrictions

from ziplime.finance.asset_restrictions import StaticRestrictions


async def initialize(context):
    restricted = StaticRestrictions([context.restricted_asset])
    context.set_asset_restrictions(restricted)

Restricted assets also report False from data.can_trade.

Cancel policies

from ziplime.finance.cancel_policy import EODCancel, NeverCancel


async def initialize(context):
    context.set_cancel_policy(EODCancel(warn_on_cancel=True))

Policy	Meaning
`EODCancel(warn_on_cancel=True)`	Cancel open orders at session end
`NeverCancel()`	Leave open orders working until filled or cancelled

Commission and slippage

Costs belong to the run, not to the strategy: pass them to run_simulation(...) or the CLI. See Costs & Commissions.

Introduction

Writing Strategies

Strategy Language

Migrating to Ziplime

Limitations

Scheduling & Controls

Calendar gates

Scheduling callbacks

`context.schedule_function(func, date_rule=None, time_rule=None, half_days=True, calendar=None)`

Date rules

Time rules

Calendars

Which hook for what

Trading controls

Error behavior

Asset restrictions

Cancel policies

Commission and slippage

​Calendar gates

​Scheduling callbacks

​context.schedule_function(func, date_rule=None, time_rule=None, half_days=True, calendar=None)

​Date rules

​Time rules

​Calendars

​Which hook for what

​Trading controls

​Error behavior

​Asset restrictions

​Cancel policies

​Commission and slippage

Calendar gates

Scheduling callbacks

`context.schedule_function(func, date_rule=None, time_rule=None, half_days=True, calendar=None)`

Date rules

Time rules

Calendars

Which hook for what

Trading controls

Error behavior

Asset restrictions

Cancel policies

Commission and slippage