Plugin

Trading sessions

Which FX centre is open on each bar, the London and New York overlap, and the high and low of the session you follow.

IndicatorNo networkDesktop onlyv1.0.0

Get early access Plugin API documentation Built in indicators

About

Forex trades around the clock, but not evenly: volume and ranges change with the centres that are open. This indicator tells a strategy, on every bar, whether Sydney, Tokyo, London and New York are open, whether London and New York overlap, and for one session you choose: whether the bar is in it, whether it is its first bar, the minutes since it opened, its high and low so far, and the high and low of the last finished session.

Every session is kept on its own city's clock: Sydney 07:00 to 16:00, Tokyo 09:00 to 18:00 (no daylight saving), London 08:00 to 17:00, New York 08:00 to 17:00. These are common conventions; the FX market has no official session hours. London and New York change their clocks on different Sundays, up to three weeks apart in March and one week apart in late October or early November, and in those weeks the overlap is an hour longer in UTC. Because the times are local, the indicator gets those weeks right, and the Monday Sydney session starts on Sunday evening in UTC, where the FX week opens.

Parameters

Name	Type	Default	Range or options	Description
`session`	choice	`"london"`	sydney, tokyo, london, new_york, custom	The session to follow; custom uses open, close and tz below.
`open`	text	`"08:00"`		Custom session only: the opening time on the clock of tz, like 09:00.
`close`	text	`"17:00"`		Custom session only: the closing time; at or before open, the session runs past midnight.
`tz`	text	`"Europe/London"`		Custom session only. A time zone name (IANA), like Europe/Berlin or America/New_York.
`weekdays`	choice	`"mon_fri"`	mon_fri, every_day	The local days a session may open on: Monday to Friday, or every day for markets that trade at the weekend. Applies to the four FX flags too.

Use it in a strategy

pythonses = ctx.plugin_indicator("trading_sessions", "sessions", {"session": "london"})
bars = ctx.bars(1)
if ses is not None and bars and ses.overlap and ses.prev_high is not None:
    if bars[-1].close > ses.prev_high:
        ctx.signal("LONG")
    elif bars[-1].close < ses.prev_low:
        ctx.signal("SHORT")

The indicator library has this as sessions: ctx.ind("sessions", session="london") reads it in a strategy, and the chart, Blocks, Rust and the Rust core have it too, with the same four sessions on their own clocks. This template stays as an example of a plugin indicator; only it takes custom hours in any time zone.

What it provides

`value`Value	1.0 when the bar is in the followed session, else 0.0.
`in_session`Value	True when the bar's start time is inside the followed session (open included, close excluded).
`session_open`Value	True on the first bar of a new session (also on the first bar of the data when it starts inside a session; check minutes_since_open).
`minutes_since_open`Value	Minutes from the session's open to the bar's start time; None outside the session.
`high, low`Value	The high and low of the running session so far, this bar included; None outside the session.
`prev_high, prev_low`Value	The high and low of the last finished session; None until one has finished.
`sydney, tokyo, london, new_york`Value	True while that centre's session is open, on its own clock.
`overlap`Value	True while London and New York are both open.

Limits

A bar counts by its start time. A bar that starts before the open but ends after it is not in the session, so pick a timeframe that lines up with the session times (H1 or finer for the four FX sessions).
Holidays are not known: a session opens on every weekday that has bars. When the data starts in the middle of a session, its high and low count from the first bar.
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{
  "high": 1.0874,
  "in_session": true,
  "london": true,
  "low": 1.0831,
  "minutes_since_open": 315,
  "new_york": true,
  "overlap": true,
  "prev_high": 1.0862,
  "prev_low": 1.0809,
  "session_open": false,
  "sydney": false,
  "tokyo": false,
  "value": 1
}

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"""Trading sessions: which of the big FX centres is open, and the high and low of one.

A strategy asks for one session to follow (London by default, or any custom
hours in any time zone) and reads, after every bar:

    in_session          the bar's start time is inside the followed session
    session_open        this bar is the first bar of a new session
    minutes_since_open  minutes from the session's open to the bar's start
    high, low           the session's high and low so far (None outside it)
    prev_high, prev_low the high and low of the last finished session
    sydney, tokyo, london, new_york   whether each centre is open
    overlap             London and New York both open

Every session is a wall clock in its own city (kit.dates.FX_SESSIONS), so
London opens at 08:00 London in winter and in summer. That matters twice a
year: London and New York change their clocks on different Sundays (up to
three weeks apart), and in those weeks the overlap is an hour longer in UTC.
Writing the hours in UTC would get those weeks wrong.

A bar belongs to a session when its start time is inside it (open included,
close excluded). A session belongs to the local day it opened on, and opens
only Monday to Friday unless `weekdays` is "every_day".
"""

from datetime import timedelta

from orionquant_engine.plugins.kit import dates

#: The followed session, by name, or "custom" with your own hours and zone.
SESSION_NAMES = ("sydney", "tokyo", "london", "new_york", "custom")

WEEKDAY_SETS = {
    "mon_fri": (dates.MON, dates.TUE, dates.WED, dates.THU, dates.FRI),
    "every_day": (dates.MON, dates.TUE, dates.WED, dates.THU, dates.FRI, dates.SAT, dates.SUN),
}


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


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

    def __init__(self, session="london", open_="08:00", close="17:00", tz="Europe/London", weekdays="mon_fri"):
        if session not in SESSION_NAMES:
            raise ValueError(f"session must be one of {', '.join(SESSION_NAMES)}")
        if weekdays not in WEEKDAY_SETS:
            raise ValueError(f"weekdays must be one of {', '.join(WEEKDAY_SETS)}")
        if session == "custom":
            self.open, self.close, self.tz = open_, close, tz
        else:
            self.open, self.close, self.tz = dates.fx_session(session)
        # Check the hours and the zone now, so a typo fails at once, not on a bar.
        self._o = dates.as_clock(self.open)
        self._c = dates.as_clock(self.close)
        dates.zone(self.tz)
        self.weekdays = WEEKDAY_SETS[weekdays]

        self.in_session = False
        self.session_open = False
        self.minutes_since_open = None
        self.high = None
        self.low = None
        self.prev_high = None
        self.prev_low = None
        self.sydney = self.tokyo = self.london = self.new_york = self.overlap = False
        self._opened_on = None  # the local day the current session opened on

    def _is_open(self, ts, open_, close, tz):
        return dates.in_session(ts, open_, close, tz, weekdays=self.weekdays)

    def _opening_day(self, ts):
        """The local day the session containing `ts` opened on (an overnight
        session that is still open after midnight opened the day before)."""
        local = dates.to_local(ts, self.tz)
        if self._c <= self._o and local.time().replace(tzinfo=None) < self._c:
            return local.date() - timedelta(days=1)
        return local.date()

    def update(self, bar):
        ts = _field(bar, "ts")
        for name in ("sydney", "tokyo", "london", "new_york"):
            setattr(self, name, self._is_open(ts, *dates.fx_session(name)))
        self.overlap = self.london and self.new_york

        self.in_session = self._is_open(ts, self.open, self.close, self.tz)
        self.session_open = False
        if not self.in_session:
            self._finish()
            return
        high, low = float(_field(bar, "high")), float(_field(bar, "low"))
        day = self._opening_day(ts)
        if day != self._opened_on:
            # A new session: the one before it is finished, even when no bar
            # outside a session came between them (a gap in the data).
            self._finish()
            self._opened_on = day
            self.session_open = True
            self.high, self.low = high, low
        else:
            self.high, self.low = max(self.high, high), min(self.low, low)
        start = dates.at_local(day, self.open, self.tz)
        self.minutes_since_open = dates.minutes_since(ts, start)

    def _finish(self):
        """Close the running session: its high and low become the previous ones."""
        if self._opened_on is not None:
            self.prev_high, self.prev_low = self.high, self.low
        self._opened_on = None
        self.high = self.low = None
        self.minutes_since_open = None

    @property
    def value(self):
        """1.0 inside the followed session, 0.0 outside it."""
        return 1.0 if self.in_session else 0.0


def make(params):
    params = params or {}
    return TradingSessions(
        session=params.get("session", "london"),
        open_=params.get("open", "08:00"),
        close=params.get("close", "17:00"),
        tz=params.get("tz", "Europe/London"),
        weekdays=params.get("weekdays", "mon_fri"),
    )


def register(api):
    api.register_indicator(
        "sessions",
        "Trading sessions",
        make,
        [
            {"key": "session", "label": "Session", "type": "choice", "default": "london",
             "options": list(SESSION_NAMES)},
            {"key": "open", "label": "Custom open (HH:MM)", "type": "text", "default": "08:00"},
            {"key": "close", "label": "Custom close (HH:MM)", "type": "text", "default": "17:00"},
            {"key": "tz", "label": "Custom time zone", "type": "text", "default": "Europe/London"},
            {"key": "weekdays", "label": "Days", "type": "choice", "default": "mon_fri",
             "options": list(WEEKDAY_SETS)},
        ],
    )