Writing strategy code

def on_session_start(ctx):   # optional — the session is about to begin
    pass

def build_entry(ctx):        # REQUIRED — construct the trade, place nothing
    return None

def on_tick(ctx):            # once per second; holds the one ctx.enter() call site
    ctx.enter()

def on_order_filled(ctx, order):   # optional — an order reached a final outcome
    pass

def on_session_end(ctx):     # optional — the session is over
    pass

# Enter between 09:45 and 09:50 ET, every trading day.
PLATFORM_ENTRY_WINDOW = {"start": "09:45", "end": "09:50"}

# Mondays, Wednesdays and Fridays only (Monday = 0 … Sunday = 6).
PLATFORM_ENTRY_WINDOW = {"start": "14:00", "end": "14:30", "days": [0, 2, 4]}

def on_tick(ctx):
    if ctx.state["armed"]:
        return
    ctx.enter()               # arm the session's one entry
    ctx.state["armed"] = True  # latch AFTER the call, never before

def build_entry(ctx):
    strike = ctx.find_strike_by_delta("put", 0.20)
    if strike == None:
        return None                     # ask me again next time
    short_put = ctx.option(strike, "put")
    long_put = ctx.option(strike - 25, "put")
    if short_put == None or long_put == None:
        return None
    credit = short_put.mid - long_put.mid
    if ctx.cmp(credit, 0.0) <= 0:
        return None                     # a credit spread always collects a credit
    entry_legs = [
        ctx.leg(short_put, "sell to open", 1),
        ctx.leg(long_put, "buy to open", 1),
    ]
    return [entry_legs, ctx.snap_to_tick(credit), "credit"]

credit = 4.50                      # $450 for one contract — store it PER SHARE
cost = ctx.net_mid(ctx.positions())  # also per share, whatever the contract count
if ctx.cmp(cost, credit * 0.5) <= 0:  # half the credit has decayed away
    ...

# One resting close — the profit target, priced at the number that triggers it.
close_legs = []
for p in ctx.positions():
    action = "buy to close" if p.direction == "short" else "sell to close"
    close_legs.append(ctx.leg(p.instrument, action, p.quantity))
ctx.take_profit_order(close_legs, target, "debit")

# Everything else — a stop, a time exit, a data bail-out — is one call.
ctx.log("exit", reason="stop_loss")
ctx.liquidate("stop_loss")
return

# A 0DTE SPX put credit spread.
#
# Sell the ~20-delta put, buy the put $25 below it for defined risk, and enter
# in the 09:45-09:50 window. Take profit at 50% of the credit collected; if the
# cost to close instead doubles, hand the position to the platform to close.
#
# Every number below is yours to change — the strikes, the width, the window,
# the targets. Press Validate to check the code, Save to publish it.

# The entry window, ET. "end" is EXCLUSIVE, so this window is 09:45:00 through
# 09:49:59. Add "days": [0, 2, 4] to trade Mondays, Wednesdays and Fridays only
# (Monday = 0). The platform places the entry inside this window and withdraws
# it if it never fills, so the strategy never watches the clock itself.
PLATFORM_ENTRY_WINDOW = {"start": "09:45", "end": "09:50"}

SHORT_DELTA = 0.20   # sell the put nearest this delta
WIDTH = 25           # dollars between the short strike and the long wing
PROFIT_AT = 0.50     # take profit once 50% of the credit has decayed away
STOP_AT = 2.00       # give up once closing costs 2x the credit collected


def on_session_start(ctx):
    # Seed every key the rest of the session reads — reading an unset key raises.
    ctx.state["armed"] = False     # the one entry has been armed
    ctx.state["closing"] = False   # a take-profit order is resting
    ctx.state["recheck"] = False   # a close came back unfilled; re-read the book
    ctx.state["credit"] = None     # the entry credit per share, from the fill


def build_entry(ctx):
    # Construct the spread from the CURRENT market and return it. The platform
    # calls this itself, possibly several times, so it must not write state or
    # place anything. Return None whenever the data isn't there yet — that is a
    # "ask me again", not a refusal.
    short_strike = ctx.find_strike_by_delta("put", SHORT_DELTA)
    if short_strike == None:
        return None
    short_put = ctx.option(short_strike, "put")
    long_put = ctx.option(short_strike - WIDTH, "put")
    if short_put == None or long_put == None:
        return None
    credit = short_put.mid - long_put.mid
    if ctx.cmp(credit, 0.0) <= 0:
        # A credit spread always collects a credit; a non-positive one means the
        # quotes are unusable this second.
        return None
    entry_legs = [
        ctx.leg(short_put, "sell to open", 1),
        ctx.leg(long_put, "buy to open", 1),
    ]
    return [entry_legs, ctx.snap_to_tick(credit), "credit"]


def on_tick(ctx):
    if not ctx.state["armed"]:
        # Arm the session's one entry, THEN latch — if the call raises, the next
        # tick tries again instead of leaving the day silently disarmed.
        ctx.enter()
        ctx.state["armed"] = True
        return
    _manage(ctx)


def _manage(ctx):
    positions = ctx.positions()
    if len(positions) == 0:
        # Either the entry is still being worked or the trade is already closed.
        return
    if ctx.state["recheck"]:
        # A close came back unfilled. Once the book is clear again, allow a new one.
        ctx.state["recheck"] = False
        if len(ctx.open_orders()) == 0:
            ctx.state["closing"] = False
    credit = ctx.state["credit"]
    if credit == None:
        # No confirmed fill price yet — nothing to measure a target against.
        return
    cost_to_close = ctx.net_mid(positions)
    if ctx.cmp(cost_to_close, credit * STOP_AT) >= 0:
        # Everything that is not a resting profit target is a liquidation: the
        # platform sweeps the working orders and closes the whole position.
        ctx.log("exit", reason="stop_loss")
        ctx.liquidate("stop_loss")
        return
    if ctx.state["closing"]:
        return
    tick = 0.10 if credit >= 3.0 else 0.05
    target = ctx.snap_to_tick((1.0 - PROFIT_AT) * credit)
    if target > credit - tick:
        # A tiny target snaps back onto the entry premium — step past it so the
        # close is strictly profitable.
        target = ctx.snap_to_tick(credit - tick)
    if target < 0.05:
        target = 0.05
    if ctx.cmp(cost_to_close, target) <= 0:
        _take_profit(ctx, positions, target)


def _take_profit(ctx, positions, price):
    # Size the close from the BOOK, never from the size the entry asked for.
    close_legs = []
    for p in positions:
        action = "buy to close" if p.direction == "short" else "sell to close"
        close_legs.append(ctx.leg(p.instrument, action, p.quantity))
    # Buying back a credit structure is always a debit — structural, not read off
    # this second's quote.
    order = ctx.take_profit_order(close_legs, price, "debit")
    if order == None:
        return
    ctx.state["closing"] = True
    ctx.log("exit", reason="profit_target")


def on_order_filled(ctx, order):
    # Fires on every terminal outcome, not just fills — and the same outcome can
    # be delivered more than once, so only set flags here, never count.
    if order.status != "filled":
        if ctx.state["closing"]:
            ctx.state["recheck"] = True
        return
    if ctx.state["credit"] == None and order.fill_price != None:
        # The first fill is the entry. Its price per share is the credit every
        # exit target is measured against.
        ctx.state["credit"] = order.fill_price


def on_session_end(ctx):
    # Anything still open here cash-settles at 16:00 ET.
    ctx.log("session_end", held=len(ctx.positions()))