Orders

Orders are async calls on context. Place them in handle_data or in scheduled callbacks — not in initialize or before_trading_start.

from ziplime.finance.execution import MarketOrder

await context.order_target_percent(
    asset=context.asset,
    target=0.5,
    style=MarketOrder(),
)

Execution styles

from ziplime.finance.execution import (
    MarketOrder,
    LimitOrder,
    StopOrder,
    StopLimitOrder,
)

Style	Example	Meaning
`MarketOrder()`	`MarketOrder()`	Fill at the run’s fill price plus slippage
`LimitOrder(limit_price)`	`LimitOrder(150.0)`	Buy no higher than the limit, sell no lower
`StopOrder(stop_price)`	`StopOrder(145.0)`	Becomes a market order once the stop is reached
`StopLimitOrder(limit_price, stop_price)`	`StopLimitOrder(151.0, 149.0)`	Becomes a limit order once the stop is reached

Fixed quantity

`await context.order(asset, amount, style, account_id=None, exchange_name=None)`

Positive amount buys or covers; negative sells or shorts.

await context.order(context.asset, 100, style=MarketOrder())
await context.order(context.asset, -50, style=MarketOrder())
await context.order(context.asset, 100, style=LimitOrder(limit_price=150.0))

Fixed money amount

`await context.order_value(asset, value, limit_price=None, stop_price=None, style=None, exchange_name=None)`

Buy or sell value worth of the asset. Pass either a style or the shorthand prices: limit_price alone means a limit order, stop_price alone a stop, both a stop-limit, neither a market order. Combining style with a price raises.

await context.order_value(context.asset, 5_000)
await context.order_value(context.asset, 5_000, limit_price=150.0)

Targets

`await context.order_target(asset, target, style, exchange_name=None)`

Adjust the position to a target number of shares or contracts.

await context.order_target(context.asset, 200, style=MarketOrder())
await context.order_target(context.asset, 0, style=MarketOrder())

`await context.order_target_value(asset, target, style, exchange_name=None)`

Adjust the position to a target notional value.

`await context.order_target_percent(asset, target, style, exchange_name=None)`

Adjust the position to a target share of portfolio value. target must be between -1 and 1. The quantity is reduced by the projected commission and slippage, so the order fits the cash it is sized against.

await context.order_target_percent(context.aapl, 0.25, style=MarketOrder())
await context.order_target_percent(context.aapl, 0.0, style=MarketOrder())

`await context.order_percent(asset, percent, style, exchange_name=None)`

Order an incremental percent of portfolio value relative to the current position. Not a target.

Rebalance a book

`await context.rebalance(weights, style=None, exchange_name=None)`

Hold exactly these weights and nothing else. Every listing named is ordered to its target weight, and every position not named is closed — the half that strategies forget, so a name drops out of the universe and quietly stays in the book.

await context.rebalance({listing: 0.1 for listing in winners})
await context.rebalance({})          # go flat

Weights are shares of portfolio value, as in order_target_percent. They are not checked against 1.0, because a futures book is levered by construction.
style defaults to MarketOrder().
A leg whose market is shut at that moment is left exactly as it is — neither ordered nor closed (since 2.11.0).
Name only listings that have a price today: ordering one with no price raises.

Open orders

`context.get_open_orders(asset=None)`

Working orders. Pass an asset to filter. Cancelled and rejected orders are removed from this book.

if context.get_open_orders(context.asset):
    return

`context.get_order(order_id, exchange_name)`

order = context.get_order(order_id, exchange_name="LIME")
if order is not None:
    print(order.status, order.filled, order.amount)

`await context.cancel_order(order_id, exchange_name, relay_status=True)`

for order in context.get_open_orders(context.asset):
    await context.cancel_order(order.id, exchange_name=order.exchange_name)

Returned order object

Order methods return an Order, or None if no order was placed.

Field	Meaning
`id`	Order id
`asset`	Ordered listing
`amount`	Requested amount
`filled`	Filled amount
`open_amount`	Remaining amount
`status`	Current status
`commission`	Accumulated commission
`dt`	Last update datetime
`exchange_name`	Exchange that owns the order

Fill timing

Where you run	Default	Switch
`ziplime run`	Next bar	`--same-bar-execution`
Local MCP server	Next bar	—
`run_simulation(...)`	Same bar	`same_bar_execution=False`

With next-bar execution an order placed in handle_data fills on the following bar, and handle_data sees a portfolio that already reflects earlier fills. Same-bar execution fills at the close of the bar the decision was made on — a price the market had not printed yet. The fill price is one bar field: close by default, or open, high, low (--fill-price / price_used_in_order_execution). No fill happens on a bar with no volume, and the slippage model caps a fill at a share of the bar’s volume, so a large order can fill over several bars.

Target orders and open orders

Target helpers size against the current position and do not count orders that haven’t filled yet. Two target calls before a fill over-order:

await context.order_target_percent(asset, 0.5, style=MarketOrder())
await context.order_target_percent(asset, 0.5, style=MarketOrder())   # 100%, not 50%

Guard with open orders, or use context.rebalance:

if not context.get_open_orders(asset):
    await context.order_target_percent(asset, 0.5, style=MarketOrder())

What raises

Ordering a ContinuousFuture — order await data.current_contract(cf) instead.
Ordering a FuturesContract from context.future_symbol — order the listing from futures_symbol, futures_chain or front_contract.
Ordering a listing whose market is closed — the error names the listing’s calendar and the simulation’s.
An order a trading control rejects, with the default on_error="fail".

Introduction

Writing Strategies

Strategy Language

Migrating to Ziplime

Limitations

Execution styles

Fixed quantity

`await context.order(asset, amount, style, account_id=None, exchange_name=None)`

Fixed money amount

`await context.order_value(asset, value, limit_price=None, stop_price=None, style=None, exchange_name=None)`

Targets

`await context.order_target(asset, target, style, exchange_name=None)`

`await context.order_target_value(asset, target, style, exchange_name=None)`

`await context.order_target_percent(asset, target, style, exchange_name=None)`

`await context.order_percent(asset, percent, style, exchange_name=None)`

Rebalance a book

`await context.rebalance(weights, style=None, exchange_name=None)`

Open orders

`context.get_open_orders(asset=None)`

`context.get_order(order_id, exchange_name)`

`await context.cancel_order(order_id, exchange_name, relay_status=True)`

Returned order object

Fill timing

Target orders and open orders

What raises

​Execution styles

​Fixed quantity

​await context.order(asset, amount, style, account_id=None, exchange_name=None)

​Fixed money amount

​await context.order_value(asset, value, limit_price=None, stop_price=None, style=None, exchange_name=None)

​Targets

​await context.order_target(asset, target, style, exchange_name=None)

​await context.order_target_value(asset, target, style, exchange_name=None)

​await context.order_target_percent(asset, target, style, exchange_name=None)

​await context.order_percent(asset, percent, style, exchange_name=None)

​Rebalance a book

​await context.rebalance(weights, style=None, exchange_name=None)

​Open orders

​context.get_open_orders(asset=None)

​context.get_order(order_id, exchange_name)

​await context.cancel_order(order_id, exchange_name, relay_status=True)

​Returned order object

​Fill timing

​Target orders and open orders

​What raises

Execution styles

Fixed quantity

`await context.order(asset, amount, style, account_id=None, exchange_name=None)`

Fixed money amount

`await context.order_value(asset, value, limit_price=None, stop_price=None, style=None, exchange_name=None)`

Targets

`await context.order_target(asset, target, style, exchange_name=None)`

`await context.order_target_value(asset, target, style, exchange_name=None)`

`await context.order_target_percent(asset, target, style, exchange_name=None)`

`await context.order_percent(asset, percent, style, exchange_name=None)`

Rebalance a book

`await context.rebalance(weights, style=None, exchange_name=None)`

Open orders

`context.get_open_orders(asset=None)`

`context.get_order(order_id, exchange_name)`

`await context.cancel_order(order_id, exchange_name, relay_status=True)`

Returned order object

Fill timing

Target orders and open orders

What raises