Plugin

Opening range

The high and low of the first minutes after a market opens, its size in daily ATR and where price is now, never before the window has closed.

IndicatorNo networkDesktop onlyv1.0.0

Get early access Plugin API documentation Built in indicators

About

The opening range is the high and low of the first minutes after a market opens: 30 minutes after 09:30 New York for US stocks and index futures, or after 09:00 Frankfurt for the DAX. Breakout traders buy above it or sell below it, and many skip days where the range is already wide compared with a normal day. This indicator gives a strategy the range, its middle, its size in units of a daily ATR, whether the close is above, inside or below it, and the range of the first hour beside it.

Nothing is reported before the window has closed, so a backtest can never trade on a range that was still forming. The open is a wall clock time in a time zone, so 09:30 New York stays 09:30 New York when the clocks change. The window starts again every local day; after local midnight the outputs are None until the new window closes.

Parameters

Name	Type	Default	Range or options	Description
`open`	text	`"09:30"`		The opening time on the clock of tz.
`tz`	text	`"America/New_York"`		A time zone name (IANA), like Europe/Berlin or America/New_York.
`minutes`	int	`30`	min 1, max 1440	The length of the window; it must end by local midnight.
`atr_period`	int	`14`	min 1, max 200	Finished local days in the daily ATR (Wilder's smoothing).

Use it in a strategy

pythonorb = ctx.plugin_indicator("opening_range", "range", {"open": "09:30", "tz": "America/New_York", "minutes": 30})
if orb is not None and orb.complete and orb.size_atr is not None and orb.size_atr < 0.5:
    if orb.position == 1:
        ctx.signal("LONG")
    elif orb.position == -1:
        ctx.signal("SHORT")

The indicator library has this as opening_range: ctx.ind("opening_range", zone="new_york", hour=9, minute=30, minutes=30) reads it, on the clock of UTC, London, New York, Tokyo or Sydney, and the chart, Blocks, Rust and the Rust core have it too. This template stays as an example of a plugin indicator; only it takes any time zone and has the first hour range.

What it provides

`high, low, mid`Value	The range of the bars that start inside the window, and its middle (also value); None until the window has closed.
`complete`Value	True from the bar that closes the window until local midnight.
`size, size_atr`Value	high - low, and that size divided by the daily ATR; size_atr is None until the ATR has warmed up.
`position`Value	1 when the bar's close is above the range, -1 below it, 0 inside; None until the window has closed.
`hour_high, hour_low`Value	The range of the first 60 minutes after the open, by the same rules.
`atr`Value	Wilder's ATR of finished local days in tz, never today; None until atr_period + 1 days have finished.

Limits

A bar belongs to the window when it starts inside it. Use a timeframe that lines up with the open and is no longer than the window (M1, M5, M15 or M30 for 09:30); with H1 bars a 09:30 window has no bar and stays None.
Holidays and half days are not known: a day without bars in the window has no range, a day with bars has one, whatever the exchange did that day. With round the clock data (forex, crypto) the window is cut from those bars.
A plugin indicator is not drawn on the chart and is not available in Blocks, Pine, Rust or C#; it runs on the run's own instrument only.

Preview

json{
  "atr": 45.7,
  "complete": true,
  "high": 5321.5,
  "hour_high": 5324,
  "hour_low": 5308.25,
  "low": 5308.25,
  "mid": 5314.875,
  "position": 1,
  "size": 13.25,
  "size_atr": 0.29,
  "value": 5314.875
}

A made-up sample that shows the shape of the output. Not vendor data and not a result.

The code

main.py, the file the app installs.

python"""Opening range: the high and low of the first minutes after a market opens.

After every bar a strategy reads:

    high, low, mid       the range of the first `minutes` after `open` (value is mid)
    size, size_atr       high - low, and that size in units of a daily ATR
    position             1 when the close is above the range, -1 below, 0 inside
    complete             True once the window has closed
    hour_high, hour_low  the range of the first 60 minutes, by the same rules

Everything is None until its window has closed, so a strategy can never act on
a range that is still forming. The window is on the wall clock of `tz`
(09:30 New York stays 09:30 New York through daylight saving) and starts again
every local day; after local midnight the outputs are None until the new
window closes.

When has a window closed? A bar belongs to it when its start time is inside
[open, open + minutes). The plugin learns the bar length from the data (the
smallest gap between two bars), and the window is complete at the close of the
bar that reaches its end. Until it knows a bar length no longer than the window
(at the start of the data, or after a weekend), it waits for the first bar that
starts at or after the end, which is one bar later and never earlier.

The daily ATR uses whole local days in `tz` that have finished, never today.
"""

from datetime import timedelta

from orionquant_engine.indicators import ATR
from orionquant_engine.plugins.kit import dates


def _field(bar, name):
    return bar[name] if isinstance(bar, dict) else getattr(bar, name)


class _Window:
    """The high and low of the bars that start inside one window of one day."""

    def __init__(self, start, end):
        self.start, self.end = start, end
        self.high = self.low = None
        self.complete = False

    def add(self, ts, high, low, step):
        if self.complete:
            return
        if self.start <= ts < self.end:
            self.high = high if self.high is None else max(self.high, high)
            self.low = low if self.low is None else min(self.low, low)
            length = self.end - self.start
            if step is not None and step <= length and ts + step >= self.end:
                self.complete = True
        elif ts >= self.end and self.high is not None:
            self.complete = True

    def get(self):
        """(high, low) once complete, else (None, None)."""
        return (self.high, self.low) if self.complete else (None, None)


class _Day:
    """A finished day, the shape the engine's ATR reads."""

    def __init__(self, high, low, close):
        self.high, self.low, self.close = high, low, close


class OpeningRange:
    """update(bar), then read the properties listed in the module docstring."""

    def __init__(self, open_="09:30", tz="America/New_York", minutes=30, atr_period=14):
        self.open = dates.as_clock(open_)
        self.tz = tz
        dates.zone(tz)  # an unknown zone fails here, not on the first bar
        self.minutes = int(minutes)
        to_midnight = 24 * 60 - (self.open.hour * 60 + self.open.minute)
        if not 1 <= self.minutes <= to_midnight:
            raise ValueError("minutes must be at least 1 and end the window by midnight")
        self._atr = ATR(max(1, int(atr_period)))

        self._prev_ts = None
        self._step = None
        self._day = None
        self._day_hlc = None
        self._range = None
        self._hour = None
        self._close = None

    def update(self, bar):
        ts = dates.to_utc(_field(bar, "ts"))
        h, low, c = (float(_field(bar, k)) for k in ("high", "low", "close"))
        if self._prev_ts is not None and ts > self._prev_ts:
            gap = ts - self._prev_ts
            self._step = gap if self._step is None else min(self._step, gap)
        self._prev_ts = ts

        day = dates.local_date(ts, self.tz)
        if day != self._day:
            if self._day_hlc is not None:
                self._atr.update(_Day(*self._day_hlc))  # yesterday is finished
            self._day = day
            self._day_hlc = [h, low, c]
            start = dates.at_local(day, self.open, self.tz)
            self._range = _Window(start, start + timedelta(minutes=self.minutes))
            self._hour = _Window(start, start + timedelta(minutes=60))
        else:
            hlc = self._day_hlc
            hlc[0], hlc[1], hlc[2] = max(hlc[0], h), min(hlc[1], low), c
        self._range.add(ts, h, low, self._step)
        self._hour.add(ts, h, low, self._step)
        self._close = c

    @property
    def complete(self):
        return bool(self._range and self._range.complete)

    @property
    def high(self):
        return self._range.get()[0] if self._range else None

    @property
    def low(self):
        return self._range.get()[1] if self._range else None

    @property
    def mid(self):
        hi, lo = self.high, self.low
        return None if hi is None else (hi + lo) / 2.0

    @property
    def value(self):
        return self.mid

    @property
    def size(self):
        hi, lo = self.high, self.low
        return None if hi is None else hi - lo

    @property
    def atr(self):
        return self._atr.value

    @property
    def size_atr(self):
        size, atr = self.size, self.atr
        return None if size is None or not atr else size / atr

    @property
    def position(self):
        hi, lo = self.high, self.low
        if hi is None:
            return None
        if self._close > hi:
            return 1
        if self._close < lo:
            return -1
        return 0

    @property
    def hour_high(self):
        return self._hour.get()[0] if self._hour else None

    @property
    def hour_low(self):
        return self._hour.get()[1] if self._hour else None


def make(params):
    params = params or {}
    return OpeningRange(
        open_=params.get("open", "09:30"),
        tz=params.get("tz", "America/New_York"),
        minutes=params.get("minutes", 30),
        atr_period=params.get("atr_period", 14),
    )


def register(api):
    api.register_indicator(
        "range",
        "Opening range",
        make,
        [
            {"key": "open", "label": "Open (HH:MM)", "type": "text", "default": "09:30"},
            {"key": "tz", "label": "Time zone", "type": "text", "default": "America/New_York"},
            {"key": "minutes", "label": "Range minutes", "type": "int", "default": 30, "min": 1, "max": 1440},
            {"key": "atr_period", "label": "ATR days", "type": "int", "default": 14, "min": 1, "max": 200},
        ],
    )