Plugin

Prior period levels

Yesterday's, last week's or last month's open, high, low and close, the running period's range, and how far price is from them in ATR.

IndicatorNo networkDesktop onlyv1.0.0

Get early access Plugin API documentation Built in indicators

About

Many traders watch the previous day's high and low, or last week's, as levels where price tends to react. This indicator gives a strategy those levels on every bar: the open, high, low and close of the last finished day, week or month, the high and low of the running one so far, and the distance from the close to the previous high and low in units of a daily ATR, so one rule works on EURUSD and on gold.

Where a day starts is a choice. The default is 17:00 New York, daylight saving included, where forex turns the day: Sunday evening is the start of Monday, so Monday's previous day is Friday. This is the same trading day the built in pivots and VWAP use with their session input on 17:00 New York, so this indicator and the chart agree. The other choices are 00:00 UTC and a custom start on any clock, for an exchange's close (16:00 America/New_York for US stocks, 17:30 Europe/Berlin for Xetra). Weeks start on Monday, months are the trading day's calendar month. Pivot points themselves are in the indicator catalogue (ctx.ind("pivots")), drawn on the chart; use this plugin for the raw levels and the ATR distance.

Parameters

Name	Type	Default	Range or options	Description
`period`	choice	`"day"`	day, week, month	The period the levels come from. Weeks start on Monday, months are the trading day's month.
`day_start`	choice	`"ny"`	ny, utc, custom	Where a day starts: 17:00 New York (as the built in pivots and VWAP), 00:00 UTC, or start in tz.
`start`	text	`"17:00"`		Custom day start only: a clock time like 16:00. A day starting at or after noon carries the date it ends on, one starting before noon the date it starts on.
`tz`	text	`"America/New_York"`		Custom day start only. A time zone name (IANA), like Europe/Berlin or America/New_York.
`atr_period`	int	`14`	min 1, max 200	Finished trading days in the daily ATR (Wilder's smoothing).

Use it in a strategy

pythonlv = ctx.plugin_indicator("prior_period_levels", "levels", {"period": "day"})
if lv is not None and lv.dist_high_atr is not None:
    if lv.new_period:
        ctx.signal("EXIT")
    elif lv.dist_high_atr > 0.25:
        ctx.signal("LONG")
    elif lv.dist_low_atr < -0.25:
        ctx.signal("SHORT")

The indicator library has this as prior_levels: ctx.ind("prior_levels", period="day", session="ny") reads the previous and the running open, high, low and close, and the chart, Blocks, Rust and the Rust core have it too. This template stays as an example of a plugin indicator; only it has the daily ATR distances and a custom day start in any time zone.

What it provides

`prev_open, prev_high, prev_low, prev_close`Value	The last finished period's open, high, low and close; None until the first period in the data has finished.
`value`Value	The same as prev_close.
`open, high, low`Value	The running period's open, and its high and low so far, this bar included.
`new_period`Value	True on the first bar of a new period.
`atr`Value	Wilder's ATR of finished trading days (same day start), never the running day; None until atr_period + 1 days have finished.
`dist_high_atr, dist_low_atr`Value	(close - prev_high) / atr and (close - prev_low) / atr: positive above the level, negative below; None while either part is missing.

Limits

A period counts from its first bar in the data: when the history starts in the middle of a day, that partial day is the first previous day.
The levels come from the run's own bars (mid prices). Holidays are not known: a day with a few bars is a day like any other.
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": 0.0074,
  "dist_high_atr": -0.16,
  "dist_low_atr": 0.95,
  "high": 1.0903,
  "low": 1.0861,
  "new_period": false,
  "open": 1.087,
  "prev_close": 1.0871,
  "prev_high": 1.0897,
  "prev_low": 1.0815,
  "prev_open": 1.0842,
  "value": 1.0871
}

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"""Prior period levels: last day's, week's or month's open, high, low and close.

After every bar a strategy reads:

    prev_open, prev_high, prev_low, prev_close   the last finished period
    value                                        the same as prev_close
    open, high, low                              the running period so far, this bar included
    new_period                                   this bar opened a new period
    atr                                          a daily ATR of finished trading days
    dist_high_atr, dist_low_atr                  (close - prev_high) / atr and (close - prev_low) / atr

Where a day starts decides everything else, so it is a parameter:

- "ny" (the default): 17:00 New York, daylight saving included. Forex turns
  the day there, so Sunday evening is the start of Monday, and Monday's
  previous day is Friday. This is the same trading day as the built in
  `pivots` and `vwap` indicators with their session input on 17:00 New York:
  the trading day is the New York date of the time seven hours later.
- "utc": 00:00 UTC.
- "custom": `start` on the clock of `tz`, for an exchange's own close, say
  16:00 America/New_York or 17:30 Europe/Berlin. A day that starts at or after
  noon is named after the date it ends on (like 17:00 New York); one that
  starts before noon after the date it starts on.

Weeks start on Monday (a Sunday evening bar of a 17:00 New York day already
belongs to Monday's week) and months are the trading day's calendar month,
again as the built in pivots count them. A period counts from its first bar in
the data, and a gap of several periods (a weekend) makes the last period with
bars the previous one.
"""

from datetime import time, timedelta

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

PERIODS = ("day", "week", "month")
DAY_STARTS = ("ny", "utc", "custom")


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


def trading_day(ts, start, tz):
    """The trading day a bar time belongs to, for days starting at `start` in `tz`."""
    local = dates.to_local(ts, tz).replace(tzinfo=None)
    offset = timedelta(hours=start.hour, minutes=start.minute, seconds=start.second)
    if start >= time(12, 0):
        return (local + (timedelta(days=1) - offset)).date()
    return (local - offset).date()


def period_of(day, period):
    """A key that changes exactly when a new period begins."""
    if period == "day":
        return day
    if period == "week":
        return day - timedelta(days=day.weekday())  # the Monday of its week
    return (day.year, day.month)


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

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


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

    def __init__(self, period="day", day_start="ny", start="17:00", tz="America/New_York", atr_period=14):
        if period not in PERIODS:
            raise ValueError(f"period must be one of {', '.join(PERIODS)}")
        if day_start not in DAY_STARTS:
            raise ValueError(f"day_start must be one of {', '.join(DAY_STARTS)}")
        if day_start == "ny":
            start, tz = "17:00", "America/New_York"
        elif day_start == "utc":
            start, tz = "00:00", "UTC"
        self.period = period
        self.start = dates.as_clock(start)
        self.tz = tz
        dates.zone(tz)  # an unknown zone fails here, not on the first bar
        self._atr = ATR(max(1, int(atr_period)))

        self._period_key = None
        self._day = None
        self._day_hlc = None  # high, low, close of the running trading day
        self._close = None
        self.new_period = False
        self.open = self.high = self.low = None
        self.prev_open = self.prev_high = self.prev_low = self.prev_close = None

    def update(self, bar):
        ts = _field(bar, "ts")
        o, h, low, c = (float(_field(bar, k)) for k in ("open", "high", "low", "close"))
        day = trading_day(ts, self.start, self.tz)

        # The daily ATR takes a trading day when it has finished, never the running one.
        if day != self._day:
            if self._day_hlc is not None:
                self._atr.update(_Day(*self._day_hlc))
            self._day = day
            self._day_hlc = [h, low, c]
        else:
            hlc = self._day_hlc
            hlc[0], hlc[1], hlc[2] = max(hlc[0], h), min(hlc[1], low), c

        key = period_of(day, self.period)
        self.new_period = key != self._period_key
        if self.new_period:
            if self._period_key is not None:
                self.prev_open, self.prev_high, self.prev_low = self.open, self.high, self.low
                self.prev_close = self._close
            self._period_key = key
            self.open, self.high, self.low = o, h, low
        else:
            self.high, self.low = max(self.high, h), min(self.low, low)
        self._close = c

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

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

    def _distance(self, level):
        atr = self.atr
        if level is None or not atr or self._close is None:
            return None
        return (self._close - level) / atr

    @property
    def dist_high_atr(self):
        return self._distance(self.prev_high)

    @property
    def dist_low_atr(self):
        return self._distance(self.prev_low)


def make(params):
    params = params or {}
    return PriorPeriodLevels(
        period=params.get("period", "day"),
        day_start=params.get("day_start", "ny"),
        start=params.get("start", "17:00"),
        tz=params.get("tz", "America/New_York"),
        atr_period=params.get("atr_period", 14),
    )


def register(api):
    api.register_indicator(
        "levels",
        "Prior period levels",
        make,
        [
            {"key": "period", "label": "Period", "type": "choice", "default": "day", "options": list(PERIODS)},
            {"key": "day_start", "label": "Day starts", "type": "choice", "default": "ny",
             "options": list(DAY_STARTS)},
            {"key": "start", "label": "Custom day start (HH:MM)", "type": "text", "default": "17:00"},
            {"key": "tz", "label": "Custom time zone", "type": "text", "default": "America/New_York"},
            {"key": "atr_period", "label": "ATR days", "type": "int", "default": 14, "min": 1, "max": 200},
        ],
    )