Overview

An algorithm file is an ordinary Python module. The engine imports it, so you can import numpy, polars, talib or anything else installed, and it calls the functions it finds by name:

context stores your strategy state and exposes the trading API.
data gives access to current and historical market data.
Lifecycle functions tell the engine when to set up, trade, prepare a session and report.

Most strategy work happens in two functions:

async def initialize(context):
    ...

async def handle_data(context, data):
    ...

Mental model

initialize is your setup block. Look up assets, store parameters, register scheduled callbacks, configure controls, mount datasets. handle_data is your trading block. It runs on every emitted bar, reads data, checks portfolio state, places orders and records metrics. before_trading_start is an optional daily preparation hook. Use it for universe selection or pipeline output. Do not place orders there. compute_signals is an optional vectorized hook, computed once over the whole history before the first bar. See Vectorized Signals. analyze is an optional reporting hook after the backtest finishes.

Minimal algorithm

from ziplime.finance.execution import MarketOrder

SYMBOLS = ["AAPL", "MSFT", "NVDA"]


async def initialize(context):
    context.assets = [await context.symbol(symbol) for symbol in SYMBOLS]


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

    weight = 1.0 / len(context.assets)
    await context.rebalance({asset: weight for asset in context.assets})
    context.record(target_weight=weight, cash=context.portfolio.cash)

Main objects

Object	Where you receive it	What it is for
`context`	Every lifecycle function	Persistent strategy state and trading API
`data`	`handle_data`, scheduled callbacks, `before_trading_start`	Current and historical data
`context.portfolio`	Any time after initialization	Cash, portfolio value, positions, returns
`context.account`	Any time after initialization	Account, leverage and margin metrics
`context.signals`	`handle_data`, when `compute_signals` is defined	Precomputed signals, cut to the current bar
`perf`	`analyze(context, perf)`	Final performance table (pandas DataFrame)

Async rule of thumb

Everything that touches the engine is awaited:

from ziplime.finance.execution import MarketOrder

asset = await context.symbol("AAPL")
prices = await data.history(assets=[asset], fields=["close"], bar_count=20)
order = await context.order_target_percent(asset, 0.25, style=MarketOrder())

Function	Define as	Notes
`initialize(context)`	`async def`	Awaited once before the first bar
`handle_data(context, data)`	`async def`	Awaited on every bar
Scheduled callbacks	`async def`	Awaited when their rule fires
`before_trading_start(context, data)`	`async def`	Awaited when it is a coroutine; data reads inside it need `await`
`compute_signals(context, prices)`	`def`	Plain array code over pandas frames
`analyze(context, perf)`	`def`	Called synchronously after the run

A missing await does not raise. The strategy silently places no orders, which reads as a strategy that found no signal. ziplime mcp’s check_strategy_code flags missing awaits before a run.

API map

Task	Primary functions
Look up assets	`context.symbol`, `context.symbols`, `context.sid`, `context.universe_symbols`
Futures, options, bonds	`context.futures_chain`, `context.front_contract`, `context.futures_symbol`, `context.option_chain`, `context.bond_symbol` — see Futures, Options & Bonds
Read current data	`await data.current(...)`
Read trailing windows	`await data.history(...)` with `bar_count` or `since`
Rank by return	`await data.returns(...)`
Point-in-time datasets	`context.huggingface_dataset`, `data_source="hf://..."` — see Point-in-Time Datasets
Place orders	`context.order`, `order_value`, `order_percent`, `order_target`, `order_target_value`, `order_target_percent`
Hold a set of weights	`context.rebalance(weights)`
Inspect orders	`context.get_open_orders`, `context.get_order`, `context.cancel_order`
Inspect portfolio	`context.portfolio`, `context.account`, portfolio helper methods
Record metrics	`context.record(...)`
Gate by calendar	`context.is_week_start()`, `context.is_month_start()`
Schedule callbacks	`context.schedule_function(...)`, `date_rules`, `time_rules`
Configure controls	`context.set_long_only`, `set_max_leverage`, `set_max_position_size`, `set_max_order_size`, `set_max_order_count`, `set_asset_restrictions`
Use pipelines	`context.attach_pipeline`, `context.pipeline_output`
Vectorize indicators	`compute_signals`, `context.signals`

Introduction

Writing Strategies

Strategy Language

Migrating to Ziplime

Limitations

Mental model

Minimal algorithm

Main objects

Async rule of thumb

API map

Recommended reading order

​Mental model

​Minimal algorithm

​Main objects

​Async rule of thumb

​API map

​Recommended reading order

Mental model

Minimal algorithm

Main objects

Async rule of thumb

API map

Recommended reading order