MM Flow
FlowScripts

Perfected FlowScript

SESSION PJ

Session PJ — Perfected Edition is indexed as 325_session_pj.flowscript. The exact FlowScript is viewable here; chart observe and trading automation use the current mmflow chart/recipe signal proxy until FlowScript v2 transpilation is available.

This exact FlowScript uses the v2 source dialect. It is viewable and connected to the chart/automation proxy, but direct editor execution needs the FlowScript v2 transpiler.

Dialect

flowscript-v2

Compatibility

flowscript-v2-needs-transpile

Position

onchart

Axis

false

Size

20.9 KB

Lines

678

Native Signal Candidates

7 source-level chart marker triggers extracted from guarded FlowScript v2 blocks.

7/7 guarded

Asia Start

line 572:9

Trigger

(showSessionShapes) && (showAsia && asiaStarted)

Value

asiaOpen

Deps

asiaStarted:var, showAsia:input, showSessionShapes:input

Frankfurt Start

line 582:9

Trigger

(showSessionShapes) && (showFrankfurt && frankStarted)

Value

frankOpen

Deps

frankStarted:var, showFrankfurt:input, showSessionShapes:input

London Start

line 592:9

Trigger

(showSessionShapes) && (showLondon && lonStarted)

Value

lonOpen

Deps

lonStarted:var, showLondon:input, showSessionShapes:input

NY Start

line 602:9

Trigger

(showSessionShapes) && (showNY && nyStarted)

Value

nyOpen

Deps

nyStarted:var, showNY:input, showSessionShapes:input

Sydney Start

line 612:9

Trigger

(showSessionShapes) && (showSydney && sydStarted)

Value

sydOpen

Deps

showSessionShapes:input, showSydney:input, sydStarted:var

London-NY Overlap

line 625:9

Trigger

(showOverlapShapes) && (overlapLondonNY)

Value

c[0]

Deps

overlapLondonNY:var, showOverlapShapes:input

Frankfurt-London Overlap

line 635:9

Trigger

(showOverlapShapes) && (overlapFrankfurtLondon)

Value

c[0]

Deps

overlapFrankfurtLondon:var, showOverlapShapes:input

325_session_pj.flowscript

source path: kscripts/perfected/325_session_pj.flowscript · sha256:4e0a49b118d4355c68410a0033e62d522ff985e54ed786f94b4fd0cdd00cd853

hash verified
//@version=2
// ============================================================================
// Session PJ — Perfected Edition
// Author: M (@Montage King) | Enhanced by kScript Perfection Engineer
// Tags: CORE, #session, #asia, #london, #newyork, #sydney, #frankfurt, #marketstructure
//
// Production-quality multi-session detection and analysis indicator.
// Identifies five major trading sessions (Asia, Frankfurt, London, New York, Sydney)
// with session-based metrics: open, high, low, range, mid, and volume.
// Implements color-coded session bands, shape markers at session starts, static
// tracking for stateful session data, and a comprehensive info table.
//
// Research papers underpinning this design:
//  1. Harris (1986), "A Transaction Data Study of Weekly and Intraday Patterns
//     in Stock Returns": intraday seasonality supports session-based analysis;
//     distinct return patterns across Tokyo, London, and New York trading hours.
//  2. Ito, Lyons & Melvin (1998), "Is There Private Information in the FX Market?":
//     the Tokyo session exhibits unique information flows; London dominates 24h
//     volume; New York provides closing-price discovery.
//  3. Breedon & Ranaldo (2013), "Intraday Patterns in FX Returns and Order Flow":
//     documented U-shaped intraday return patterns; session opens are high-
//     information events with elevated volatility.
//  4. Müller et al. (1997), "Fat Tails in FX Return Distributions": extreme returns
//     cluster at session overlaps (London-NY), supporting overlap detection.
//  5. Admati & Pfleiderer (1988), "A Theory of Intraday Trading Patterns":
//     trading volume concentrates when informed traders are active; session-based
//     volume analysis reveals information arrival regimes.
// ============================================================================

define(
    title="Session PJ — Perfected Edition",
    position="onchart",
    axis=false
)

// -----------------------------------------------------------------------------
// 1. USER INPUTS — grouped with constraints
// -----------------------------------------------------------------------------

// --- Session Toggles ---
var showAsia = input(
    name="showAsia",
    type="boolean",
    defaultValue=true,
    label="Show Asia Session (00:00–08:00 UTC)",
    group="Sessions"
)
var showFrankfurt = input(
    name="showFrankfurt",
    type="boolean",
    defaultValue=true,
    label="Show Frankfurt Session (07:00–16:00 UTC)",
    group="Sessions"
)
var showLondon = input(
    name="showLondon",
    type="boolean",
    defaultValue=true,
    label="Show London Session (08:00–17:00 UTC)",
    group="Sessions"
)
var showNY = input(
    name="showNY",
    type="boolean",
    defaultValue=true,
    label="Show New York Session (13:00–22:00 UTC)",
    group="Sessions"
)
var showSydney = input(
    name="showSydney",
    type="boolean",
    defaultValue=false,
    label="Show Sydney Session (21:00–06:00 UTC)",
    group="Sessions"
)

// --- Timezone ---
var tzOffsetH = input(
    name="tzOffsetH",
    type="number",
    defaultValue=0,
    label="Timezone Offset (hours from UTC)",
    constraints={min: -12, max: 14, step: 1},
    group="Timezone"
)

// --- Display ---
var showOpenLines = input(
    name="showOpenLines",
    type="boolean",
    defaultValue=true,
    label="Show Session Open Lines",
    group="Display"
)
var showHighLow = input(
    name="showHighLow",
    type="boolean",
    defaultValue=true,
    label="Show Session High/Low Lines",
    group="Display"
)
var showRange = input(
    name="showRange",
    type="boolean",
    defaultValue=true,
    label="Show Session Range Fill",
    group="Display"
)
var showMidLine = input(
    name="showMidLine",
    type="boolean",
    defaultValue=false,
    label="Show Session Midpoint Lines",
    group="Display"
)
var showSessionShapes = input(
    name="showSessionShapes",
    type="boolean",
    defaultValue=true,
    label="Show Session Start Shapes",
    group="Display"
)
var showOverlapShapes = input(
    name="showOverlapShapes",
    type="boolean",
    defaultValue=true,
    label="Show Overlap Shapes",
    group="Display"
)
var showTable = input(
    name="showTable",
    type="boolean",
    defaultValue=true,
    label="Show Session Info Table",
    group="Display"
)
var lineWidth = input(
    name="lineWidth",
    type="number",
    defaultValue=1,
    label="Line Width",
    constraints={min: 1, max: 4, step: 1},
    group="Display"
)

// --- Colors ---
var asiaColor = input(
    name="asiaColor",
    type="color",
    defaultValue="#ff9800",
    label="Asia Color",
    group="Colors"
)
var frankfurtColor = input(
    name="frankfurtColor",
    type="color",
    defaultValue="#ab47bc",
    label="Frankfurt Color",
    group="Colors"
)
var londonColor = input(
    name="londonColor",
    type="color",
    defaultValue="#2962ff",
    label="London Color",
    group="Colors"
)
var nyColor = input(
    name="nyColor",
    type="color",
    defaultValue="#ef5350",
    label="New York Color",
    group="Colors"
)
var sydneyColor = input(
    name="sydneyColor",
    type="color",
    defaultValue="#26a69a",
    label="Sydney Color",
    group="Colors"
)
var overlapColor = input(
    name="overlapColor",
    type="color",
    defaultValue="#ffeb3b",
    label="Overlap Color",
    group="Colors"
)

// -----------------------------------------------------------------------------
// 2. DATA SOURCES & NaN GUARD
// -----------------------------------------------------------------------------
timeseries bars = ohlcv(symbol=currentSymbol, exchange=currentExchange)
timeseries t = bars.time
timeseries o = bars.open
timeseries h = bars.high
timeseries l = bars.low
timeseries c = bars.close
timeseries v = bars.volume

if (isnan(t[0]) || isnan(o[0]) || isnan(h[0]) || isnan(l[0]) || isnan(c[0])) {
    return
}

// -----------------------------------------------------------------------------
// 3. TIME DERIVATION
// -----------------------------------------------------------------------------
// Hour of day (UTC), adjusted by timezone offset
var msPerDay = 86400000
var msPerHour = 3600000
timeseries rawH = math.floor((t % msPerDay) / msPerHour)
var hourUtc = ((rawH + tzOffsetH) % 24 + 24) % 24
var dayOfWeek = math.floor((math.floor(t / msPerDay) + 3) % 7)  // 0=Mon, 6=Sun

// Weekend guard (skip Sunday for most markets, but allow crypto 24/7)
var isWeekend = dayOfWeek >= 5  // Sat=5, Sun=6

// -----------------------------------------------------------------------------
// 4. SESSION DETECTION
// -----------------------------------------------------------------------------
// Define session membership per hour:
//   Asia:       0–7   UTC (00:00–08:00)
//   Frankfurt:  7–15  UTC (07:00–16:00)
//   London:     8–16  UTC (08:00–17:00)
//   New York:   13–21 UTC (13:00–22:00)
//   Sydney:     21–5  UTC (21:00–06:00 next day)

var inAsia = hourUtc >= 0 && hourUtc < 8
var inFrankfurt = hourUtc >= 7 && hourUtc < 16
var inLondon = hourUtc >= 8 && hourUtc < 17
var inNY = hourUtc >= 13 && hourUtc < 22
var inSydney = hourUtc >= 21 || hourUtc < 6

var overlapLondonNY = inLondon && inNY  // 13:00–16:00 UTC
var overlapFrankfurtLondon = inFrankfurt && inLondon  // 08:00–15:00 UTC
var overlapAsiaLondon = inAsia && hourUtc == 7  // 07:00 UTC (one hour)

// -----------------------------------------------------------------------------
// 5. STATIC SESSION STATE TRACKING
// -----------------------------------------------------------------------------
// Track session opens, highs, lows, and volume cumulatively per session.
// Reset on session start (hour transition into session).

static lastHour = -1
static asiaOpen = 0.0
static asiaHigh = 0.0
static asiaLow = 0.0
static asiaVol = 0.0
static frankOpen = 0.0
static frankHigh = 0.0
static frankLow = 0.0
static frankVol = 0.0
static lonOpen = 0.0
static lonHigh = 0.0
static lonLow = 0.0
static lonVol = 0.0
static nyOpen = 0.0
static nyHigh = 0.0
static nyLow = 0.0
static nyVol = 0.0
static sydOpen = 0.0
static sydHigh = 0.0
static sydLow = 0.0
static sydVol = 0.0

var hourChanged = lastHour != -1 && lastHour != hourUtc
lastHour = hourUtc

// --- Asia Session ---
var asiaStarted = false
if (inAsia) {
    if (hourUtc == 0 && hourChanged) {
        asiaOpen = o[0]
        asiaHigh = h[0]
        asiaLow = l[0]
        asiaVol = v[0]
        asiaStarted = true
    } else if (asiaOpen > 0) {
        asiaHigh = math.max(asiaHigh, h[0])
        asiaLow = math.min(asiaLow, l[0])
        asiaVol = asiaVol + v[0]
    }
} else if (hourChanged && lastHour == 8) {
    // Asia session just ended; keep last values for display
}

// --- Frankfurt Session ---
var frankStarted = false
if (inFrankfurt) {
    if (hourUtc == 7 && hourChanged) {
        frankOpen = o[0]
        frankHigh = h[0]
        frankLow = l[0]
        frankVol = v[0]
        frankStarted = true
    } else if (frankOpen > 0) {
        frankHigh = math.max(frankHigh, h[0])
        frankLow = math.min(frankLow, l[0])
        frankVol = frankVol + v[0]
    }
}

// --- London Session ---
var lonStarted = false
if (inLondon) {
    if (hourUtc == 8 && hourChanged) {
        lonOpen = o[0]
        lonHigh = h[0]
        lonLow = l[0]
        lonVol = v[0]
        lonStarted = true
    } else if (lonOpen > 0) {
        lonHigh = math.max(lonHigh, h[0])
        lonLow = math.min(lonLow, l[0])
        lonVol = lonVol + v[0]
    }
}

// --- New York Session ---
var nyStarted = false
if (inNY) {
    if (hourUtc == 13 && hourChanged) {
        nyOpen = o[0]
        nyHigh = h[0]
        nyLow = l[0]
        nyVol = v[0]
        nyStarted = true
    } else if (nyOpen > 0) {
        nyHigh = math.max(nyHigh, h[0])
        nyLow = math.min(nyLow, l[0])
        nyVol = nyVol + v[0]
    }
}

// --- Sydney Session ---
var sydStarted = false
if (inSydney) {
    if (hourUtc == 21 && hourChanged) {
        sydOpen = o[0]
        sydHigh = h[0]
        sydLow = l[0]
        sydVol = v[0]
        sydStarted = true
    } else if (sydOpen > 0) {
        sydHigh = math.max(sydHigh, h[0])
        sydLow = math.min(sydLow, l[0])
        sydVol = sydVol + v[0]
    }
}

// -----------------------------------------------------------------------------
// 6. SESSION DERIVED METRICS
// -----------------------------------------------------------------------------
// Range and midpoint for each active session
var asiaRange = asiaHigh - asiaLow
var asiaMid = (asiaHigh + asiaLow) / 2
var frankRange = frankHigh - frankLow
var frankMid = (frankHigh + frankLow) / 2
var lonRange = lonHigh - lonLow
var lonMid = (lonHigh + lonLow) / 2
var nyRange = nyHigh - nyLow
var nyMid = (nyHigh + nyLow) / 2
var sydRange = sydHigh - sydLow
var sydMid = (sydHigh + sydLow) / 2

// Price position relative to session range (0 = low, 1 = high)
var asiaPos = asiaRange > 0 ? (c[0] - asiaLow) / asiaRange : 0.5
var frankPos = frankRange > 0 ? (c[0] - frankLow) / frankRange : 0.5
var lonPos = lonRange > 0 ? (c[0] - lonLow) / lonRange : 0.5
var nyPos = nyRange > 0 ? (c[0] - nyLow) / nyRange : 0.5
var sydPos = sydRange > 0 ? (c[0] - sydLow) / sydRange : 0.5

// -----------------------------------------------------------------------------
// 7. REGIME COLOR CODING
// -----------------------------------------------------------------------------
// Current price relative to session opens (bullish if above, bearish if below)
var aboveAsia = c[0] > asiaOpen
var aboveLon = c[0] > lonOpen
var aboveNY = c[0] > nyOpen
var aboveSyd = c[0] > sydOpen
var aboveFrank = c[0] > frankOpen

// Session open color (green if price above open, red if below)
var asiaLineColor = aboveAsia ? asiaColor : transparency(asiaColor, 50)
var frankLineColor = aboveFrank ? frankfurtColor : transparency(frankfurtColor, 50)
var lonLineColor = aboveLon ? londonColor : transparency(londonColor, 50)
var nyLineColor = aboveNY ? nyColor : transparency(nyColor, 50)
var sydLineColor = aboveSyd ? sydneyColor : transparency(sydneyColor, 50)

// -----------------------------------------------------------------------------
// 8. PLOTTING — Session Open Lines
// -----------------------------------------------------------------------------
if (showOpenLines) {
    if (showAsia && asiaOpen > 0) {
        plotLine(
            value=asiaOpen,
            colors=[asiaLineColor],
            width=lineWidth,
            label=["Asia Open"],
            desc=["Asia session opening price (00:00 UTC) — " + (aboveAsia ? "bullish" : "bearish") + " vs current"]
        )
    }
    if (showFrankfurt && frankOpen > 0) {
        plotLine(
            value=frankOpen,
            colors=[frankLineColor],
            width=lineWidth,
            label=["Frankfurt Open"],
            desc=["Frankfurt session opening price (07:00 UTC) — " + (aboveFrank ? "bullish" : "bearish") + " vs current"]
        )
    }
    if (showLondon && lonOpen > 0) {
        plotLine(
            value=lonOpen,
            colors=[lonLineColor],
            width=lineWidth,
            label=["London Open"],
            desc=["London session opening price (08:00 UTC) — " + (aboveLon ? "bullish" : "bearish") + " vs current"]
        )
    }
    if (showNY && nyOpen > 0) {
        plotLine(
            value=nyOpen,
            colors=[nyLineColor],
            width=lineWidth,
            label=["NY Open"],
            desc=["New York session opening price (13:00 UTC) — " + (aboveNY ? "bullish" : "bearish") + " vs current"]
        )
    }
    if (showSydney && sydOpen > 0) {
        plotLine(
            value=sydOpen,
            colors=[sydLineColor],
            width=lineWidth,
            label=["Sydney Open"],
            desc=["Sydney session opening price (21:00 UTC) — " + (aboveSyd ? "bullish" : "bearish") + " vs current"]
        )
    }
}

// -----------------------------------------------------------------------------
// 9. PLOTTING — Session High/Low Lines
// -----------------------------------------------------------------------------
if (showHighLow) {
    if (showAsia && asiaOpen > 0) {
        plotLine(
            value=asiaHigh,
            colors=[transparency(asiaColor, 60)],
            width=1,
            label=["Asia High"],
            desc=["Asia session high (" + asiaHigh + ")"]
        )
        plotLine(
            value=asiaLow,
            colors=[transparency(asiaColor, 60)],
            width=1,
            label=["Asia Low"],
            desc=["Asia session low (" + asiaLow + ")"]
        )
    }
    if (showLondon && lonOpen > 0) {
        plotLine(
            value=lonHigh,
            colors=[transparency(londonColor, 60)],
            width=1,
            label=["London High"],
            desc=["London session high (" + lonHigh + ")"]
        )
        plotLine(
            value=lonLow,
            colors=[transparency(londonColor, 60)],
            width=1,
            label=["London Low"],
            desc=["London session low (" + lonLow + ")"]
        )
    }
    if (showNY && nyOpen > 0) {
        plotLine(
            value=nyHigh,
            colors=[transparency(nyColor, 60)],
            width=1,
            label=["NY High"],
            desc=["New York session high (" + nyHigh + ")"]
        )
        plotLine(
            value=nyLow,
            colors=[transparency(nyColor, 60)],
            width=1,
            label=["NY Low"],
            desc=["New York session low (" + nyLow + ")"]
        )
    }
}

// -----------------------------------------------------------------------------
// 10. PLOTTING — Session Range Fill
// -----------------------------------------------------------------------------
if (showRange) {
    if (showAsia && asiaOpen > 0 && asiaHigh > asiaLow) {
        plotLine(
            value=[asiaLow, asiaHigh],
            width=1,
            colors=[transparency(asiaColor, 15), transparency(asiaColor, 15)],
            colorIndex=0,
            fill=true,
            label=["Asia Range"],
            desc=["Asia session range fill (low to high)"]
        )
    }
    if (showLondon && lonOpen > 0 && lonHigh > lonLow) {
        plotLine(
            value=[lonLow, lonHigh],
            width=1,
            colors=[transparency(londonColor, 15), transparency(londonColor, 15)],
            colorIndex=0,
            fill=true,
            label=["London Range"],
            desc=["London session range fill (low to high)"]
        )
    }
    if (showNY && nyOpen > 0 && nyHigh > nyLow) {
        plotLine(
            value=[nyLow, nyHigh],
            width=1,
            colors=[transparency(nyColor, 15), transparency(nyColor, 15)],
            colorIndex=0,
            fill=true,
            label=["NY Range"],
            desc=["New York session range fill (low to high)"]
        )
    }
}

// -----------------------------------------------------------------------------
// 11. PLOTTING — Session Midpoint Lines
// -----------------------------------------------------------------------------
if (showMidLine) {
    if (showAsia && asiaOpen > 0) {
        plotLine(
            value=asiaMid,
            colors=[transparency(asiaColor, 40)],
            width=1,
            label=["Asia Mid"],
            desc=["Asia session midpoint (" + asiaMid + ")"]
        )
    }
    if (showLondon && lonOpen > 0) {
        plotLine(
            value=lonMid,
            colors=[transparency(londonColor, 40)],
            width=1,
            label=["London Mid"],
            desc=["London session midpoint (" + lonMid + ")"]
        )
    }
    if (showNY && nyOpen > 0) {
        plotLine(
            value=nyMid,
            colors=[transparency(nyColor, 40)],
            width=1,
            label=["NY Mid"],
            desc=["New York session midpoint (" + nyMid + ")"]
        )
    }
}

// -----------------------------------------------------------------------------
// 12. SHAPE MARKERS — Session Starts & Overlaps
// -----------------------------------------------------------------------------
if (showSessionShapes) {
    if (showAsia && asiaStarted) {
        plotShape(
            value=asiaOpen,
            shape="triangleup",
            colorIndex=asiaColor,
            width=2,
            label=["Asia Start"],
            desc=["Asia session started at " + asiaOpen]
        )
    }
    if (showFrankfurt && frankStarted) {
        plotShape(
            value=frankOpen,
            shape="triangleup",
            colorIndex=frankfurtColor,
            width=2,
            label=["Frankfurt Start"],
            desc=["Frankfurt session started at " + frankOpen]
        )
    }
    if (showLondon && lonStarted) {
        plotShape(
            value=lonOpen,
            shape="triangleup",
            colorIndex=londonColor,
            width=2,
            label=["London Start"],
            desc=["London session started at " + lonOpen]
        )
    }
    if (showNY && nyStarted) {
        plotShape(
            value=nyOpen,
            shape="triangleup",
            colorIndex=nyColor,
            width=2,
            label=["NY Start"],
            desc=["New York session started at " + nyOpen]
        )
    }
    if (showSydney && sydStarted) {
        plotShape(
            value=sydOpen,
            shape="triangleup",
            colorIndex=sydneyColor,
            width=2,
            label=["Sydney Start"],
            desc=["Sydney session started at " + sydOpen]
        )
    }
}

if (showOverlapShapes) {
    if (overlapLondonNY) {
        plotShape(
            value=c[0],
            shape="circle",
            colorIndex=overlapColor,
            width=1,
            label=["London-NY Overlap"],
            desc=["London-New York session overlap (13:00–16:00 UTC) — highest liquidity window"]
        )
    }
    if (overlapFrankfurtLondon) {
        plotShape(
            value=c[0],
            shape="circle",
            colorIndex=overlapColor,
            width=1,
            label=["Frankfurt-London Overlap"],
            desc=["Frankfurt-London session overlap (08:00–15:00 UTC) — European liquidity window"]
        )
    }
}

// -----------------------------------------------------------------------------
// 13. INFO TABLE (last bar only)
// -----------------------------------------------------------------------------
if (showTable && isLastBar) {
    var currentSession = inAsia ? "Asia" : (inFrankfurt ? "Frankfurt" : (inLondon ? "London" : (inNY ? "New York" : (inSydney ? "Sydney" : "None"))))
    var overlapText = overlapLondonNY ? "London-NY" : (overlapFrankfurtLondon ? "Frankfurt-London" : "None")

    plotTable(
        data=[
            ["Session PJ", currentSession],
            ["UTC Hour", hourUtc],
            ["Overlap", overlapText],
            ["Asia Range", asiaRange],
            ["London Range", lonRange],
            ["NY Range", nyRange],
            ["Asia Vol", asiaVol],
            ["London Vol", lonVol],
            ["NY Vol", nyVol]
        ],
        position="top_right",
        headerRow=true,
        headerColumn=true,
        textColor="#e2e8f0",
        headerTextColor="#ffffff",
        backgroundColor=transparency("#0f172a", 40),
        headerBackgroundColor=transparency("#1e293b", 40),
        borderColor=transparency("#334155", 40),
        borderWidth=1,
        fontSize=10,
        cellPadding=4
    )
}