Candlestick Patterns

48+ CDL pattern recognition operators

Overview

This page documents 60 operators (role: INDICATOR).

Quick Reference

Operator	Role	Key Parameters	Ephemeral
CDLDOJI	INDICATOR	—	No
CDLHAMMER	INDICATOR	—	No
CDLHANGINGMAN	INDICATOR	—	No
CDLINVERTEDHAMMER	INDICATOR	—	No
CDLSHOOTINGSTAR	INDICATOR	—	No
CDLENGULFING	INDICATOR	—	No
CDLHARAMI	INDICATOR	—	No
CDLMORNINGSTAR	INDICATOR	—	No
CDLEVENINGSTAR	INDICATOR	—	No
CDLMARUBOZU	INDICATOR	—	No
CDL3WHITESOLDIERS	INDICATOR	—	No
CDL3BLACKCROWS	INDICATOR	—	No
CDL2CROWS	INDICATOR	—	No
CDL3INSIDE	INDICATOR	—	No
CDL3LINESTRIKE	INDICATOR	—	No
CDL3STARSINSOUTH	INDICATOR	—	No
CDLABANDONEDBABY	INDICATOR	—	No
CDLADVANCEBLOCK	INDICATOR	—	No
CDLBELTHOLD	INDICATOR	—	No
CDLBREAKAWAY	INDICATOR	—	No
CDLCLOSINGMARUBOZU	INDICATOR	—	No
CDLCONCEALBABYSWALL	INDICATOR	—	No
CDLCOUNTERATTACK	INDICATOR	—	No
CDLDARKCLOUDCOVER	INDICATOR	—	No
CDLDOJISTAR	INDICATOR	—	No
CDLDRAGONFLYDOJI	INDICATOR	—	No
CDLEVENINGDOJISTAR	INDICATOR	—	No
CDLGAPSIDESIDEWHITE	INDICATOR	—	No
CDLGRAVESTONEDOJI	INDICATOR	—	No
CDLHARAMICROSS	INDICATOR	—	No
CDLHIGHWAVE	INDICATOR	—	No
CDLHIKKAKE	INDICATOR	—	No
CDLHIKKAKEMOD	INDICATOR	—	No
CDLHOMINGPIGEON	INDICATOR	—	No
CDLIDENTICAL3CROWS	INDICATOR	—	No
CDLINNECK	INDICATOR	—	No
CDLKICKING	INDICATOR	—	No
CDLKICKINGBYLENGTH	INDICATOR	—	No
CDLLADDERBOTTOM	INDICATOR	—	No
CDLLONGLEGGEDDOJI	INDICATOR	—	No
CDLLONGLINE	INDICATOR	—	No
CDLMATCHINGLOW	INDICATOR	—	No
CDLMATHOLD	INDICATOR	—	No
CDLMORNINGDOJISTAR	INDICATOR	—	No
CDLONNECK	INDICATOR	—	No
CDLPIERCING	INDICATOR	—	No
CDLRICKSHAWMAN	INDICATOR	—	No
CDLRISEFALL3METHODS	INDICATOR	—	No
CDLSEPARATINGLINES	INDICATOR	—	No
CDLSHORTLINE	INDICATOR	—	No
CDLSPINNINGTOP	INDICATOR	—	No
CDLSTALLEDPATTERN	INDICATOR	—	No
CDLSTICKSANDWICH	INDICATOR	—	No
CDLTAKURI	INDICATOR	—	No
CDLTASUKIGAP	INDICATOR	—	No
CDLTHRUSTING	INDICATOR	—	No
CDLTRISTAR	INDICATOR	—	No
CDLUNIQUE3RIVER	INDICATOR	—	No
CDLUPSIDEGAP2CROWS	INDICATOR	—	No
CDLXSIDEGAP3METHODS	INDICATOR	—	No

---

CDLDOJI

Doji pattern - Open and close are nearly equal.

Example: pattern = CDLDOJI( Input(“FIELD:open”, timeframe=“1m”, lookback=5), Input(“FIELD:high”, timeframe=“1m”, lookback=5), Input(“FIELD:low”, timeframe=“1m”, lookback=5), Input(“FIELD:close”, timeframe=“1m”, lookback=5), )

Role: INDICATOR | Ephemeral: No

Parameters

Parameter	Type	Default	Description
open_	'Input'	Required
high	'Input'	Required
low	'Input'	Required
close	'Input'	Required

Usage

pattern = CDLDOJI(
    Input("FIELD:open", timeframe="1m", lookback=5),
    Input("FIELD:high", timeframe="1m", lookback=5),
    Input("FIELD:low", timeframe="1m", lookback=5),
    Input("FIELD:close", timeframe="1m", lookback=5),
)

Source Code

Full compute() implementation — no hidden logic.

def compute(self, data, timestamp=None, context=None) -> TaggedArray:
    if not isinstance(data, list) or len(data) < 4:
        return self._empty_output()

    n_time = len(data[0])
    if n_time == 0:
        return self._empty_output()

    o, h, l, c = self._get_ohlc(data)
    n_symbols = len(o)
    exists = data[3][-1].exists
    valid = data[3][-1].valid
    result = np.zeros(n_symbols)

    for i in range(n_symbols):
        if exists[i] and valid[i] and not any(np.isnan([o[i], h[i], l[i], c[i]])):
            body = self._body_size(o[i], c[i])
            range_size = h[i] - l[i]
            if range_size > 0 and body / range_size < 0.1:  # Very small body
                result[i] = 100.0  # Neutral but detected

    result_valid = exists & valid
    return TaggedArray(
        value=result,
        exists=exists,
        valid=result_valid,
        updated=np.ones(n_symbols, dtype=bool),
    )

_{Source: apps/trading/operators/indicator/patterns.py}

---

CDLHAMMER

Hammer pattern - Bullish reversal at bottom.

Example: pattern = CDLHAMMER( Input(“FIELD:open”, timeframe=“1m”, lookback=5), Input(“FIELD:high”, timeframe=“1m”, lookback=5), Input(“FIELD:low”, timeframe=“1m”, lookback=5), Input(“FIELD:close”, timeframe=“1m”, lookback=5), )

Role: INDICATOR | Ephemeral: No

Parameters

Parameter	Type	Default	Description
open_	'Input'	Required
high	'Input'	Required
low	'Input'	Required
close	'Input'	Required

Usage

pattern = CDLHAMMER(
    Input("FIELD:open", timeframe="1m", lookback=5),
    Input("FIELD:high", timeframe="1m", lookback=5),
    Input("FIELD:low", timeframe="1m", lookback=5),
    Input("FIELD:close", timeframe="1m", lookback=5),
)

Source Code

Full compute() implementation — no hidden logic.

def compute(self, data, timestamp=None, context=None) -> TaggedArray:
    if not isinstance(data, list) or len(data) < 4:
        return self._empty_output()

    n_time = len(data[0])
    if n_time == 0:
        return self._empty_output()

    o, h, l, c = self._get_ohlc(data)
    n_symbols = len(o)
    exists = data[3][-1].exists
    valid = data[3][-1].valid
    result = np.zeros(n_symbols)

    for i in range(n_symbols):
        if exists[i] and valid[i] and not any(np.isnan([o[i], h[i], l[i], c[i]])):
            body = self._body_size(o[i], c[i])
            lower_shadow = self._lower_shadow(o[i], l[i], c[i])
            upper_shadow = self._upper_shadow(o[i], h[i], c[i])

            if body > 0:
                # Hammer: long lower shadow, small upper shadow
                if lower_shadow >= 2 * body and upper_shadow <= body * 0.3:
                    result[i] = 100.0  # Bullish

    result_valid = exists & valid
    return TaggedArray(
        value=result,
        exists=exists,
        valid=result_valid,
        updated=np.ones(n_symbols, dtype=bool),
    )

_{Source: apps/trading/operators/indicator/patterns.py}

---

CDLHANGINGMAN

Hanging Man pattern - Bearish reversal at top (same shape as hammer).

Example: pattern = CDLHANGINGMAN( Input(“FIELD:open”, timeframe=“1m”, lookback=5), Input(“FIELD:high”, timeframe=“1m”, lookback=5), Input(“FIELD:low”, timeframe=“1m”, lookback=5), Input(“FIELD:close”, timeframe=“1m”, lookback=5), )

Role: INDICATOR | Ephemeral: No

Parameters

Parameter	Type	Default	Description
open_	'Input'	Required
high	'Input'	Required
low	'Input'	Required
close	'Input'	Required

Usage

pattern = CDLHANGINGMAN(
    Input("FIELD:open", timeframe="1m", lookback=5),
    Input("FIELD:high", timeframe="1m", lookback=5),
    Input("FIELD:low", timeframe="1m", lookback=5),
    Input("FIELD:close", timeframe="1m", lookback=5),
)

Source Code

Full compute() implementation — no hidden logic.

def compute(self, data, timestamp=None, context=None) -> TaggedArray:
    if not isinstance(data, list) or len(data) < 4:
        return self._empty_output()

    n_time = len(data[0])
    if n_time == 0:
        return self._empty_output()

    o, h, l, c = self._get_ohlc(data)
    n_symbols = len(o)
    exists = data[3][-1].exists
    valid = data[3][-1].valid
    result = np.zeros(n_symbols)

    for i in range(n_symbols):
        if exists[i] and valid[i] and not any(np.isnan([o[i], h[i], l[i], c[i]])):
            body = self._body_size(o[i], c[i])
            lower_shadow = self._lower_shadow(o[i], l[i], c[i])
            upper_shadow = self._upper_shadow(o[i], h[i], c[i])

            if body > 0:
                if lower_shadow >= 2 * body and upper_shadow <= body * 0.3:
                    result[i] = -100.0  # Bearish

    result_valid = exists & valid
    return TaggedArray(
        value=result,
        exists=exists,
        valid=result_valid,
        updated=np.ones(n_symbols, dtype=bool),
    )

_{Source: apps/trading/operators/indicator/patterns.py}

---

CDLINVERTEDHAMMER

Inverted Hammer pattern - Bullish reversal.

Example: pattern = CDLINVERTEDHAMMER( Input(“FIELD:open”, timeframe=“1m”, lookback=5), Input(“FIELD:high”, timeframe=“1m”, lookback=5), Input(“FIELD:low”, timeframe=“1m”, lookback=5), Input(“FIELD:close”, timeframe=“1m”, lookback=5), )

Role: INDICATOR | Ephemeral: No

Parameters

Parameter	Type	Default	Description
open_	'Input'	Required
high	'Input'	Required
low	'Input'	Required
close	'Input'	Required

Usage

pattern = CDLINVERTEDHAMMER(
    Input("FIELD:open", timeframe="1m", lookback=5),
    Input("FIELD:high", timeframe="1m", lookback=5),
    Input("FIELD:low", timeframe="1m", lookback=5),
    Input("FIELD:close", timeframe="1m", lookback=5),
)

Source Code

Full compute() implementation — no hidden logic.

def compute(self, data, timestamp=None, context=None) -> TaggedArray:
    if not isinstance(data, list) or len(data) < 4:
        return self._empty_output()

    n_time = len(data[0])
    if n_time == 0:
        return self._empty_output()

    o, h, l, c = self._get_ohlc(data)
    n_symbols = len(o)
    exists = data[3][-1].exists
    valid = data[3][-1].valid
    result = np.zeros(n_symbols)

    for i in range(n_symbols):
        if exists[i] and valid[i] and not any(np.isnan([o[i], h[i], l[i], c[i]])):
            body = self._body_size(o[i], c[i])
            upper_shadow = self._upper_shadow(o[i], h[i], c[i])
            lower_shadow = self._lower_shadow(o[i], l[i], c[i])

            if body > 0:
                if upper_shadow >= 2 * body and lower_shadow <= body * 0.3:
                    result[i] = 100.0

    result_valid = exists & valid
    return TaggedArray(
        value=result,
        exists=exists,
        valid=result_valid,
        updated=np.ones(n_symbols, dtype=bool),
    )

_{Source: apps/trading/operators/indicator/patterns.py}

---

CDLSHOOTINGSTAR

Shooting Star pattern - Bearish reversal.

Example: pattern = CDLSHOOTINGSTAR( Input(“FIELD:open”, timeframe=“1m”, lookback=5), Input(“FIELD:high”, timeframe=“1m”, lookback=5), Input(“FIELD:low”, timeframe=“1m”, lookback=5), Input(“FIELD:close”, timeframe=“1m”, lookback=5), )

Role: INDICATOR | Ephemeral: No

Parameters

Parameter	Type	Default	Description
open_	'Input'	Required
high	'Input'	Required
low	'Input'	Required
close	'Input'	Required

Usage

pattern = CDLSHOOTINGSTAR(
    Input("FIELD:open", timeframe="1m", lookback=5),
    Input("FIELD:high", timeframe="1m", lookback=5),
    Input("FIELD:low", timeframe="1m", lookback=5),
    Input("FIELD:close", timeframe="1m", lookback=5),
)

Source Code

Full compute() implementation — no hidden logic.

def compute(self, data, timestamp=None, context=None) -> TaggedArray:
    if not isinstance(data, list) or len(data) < 4:
        return self._empty_output()

    n_time = len(data[0])
    if n_time == 0:
        return self._empty_output()

    o, h, l, c = self._get_ohlc(data)
    n_symbols = len(o)
    exists = data[3][-1].exists
    valid = data[3][-1].valid
    result = np.zeros(n_symbols)

    for i in range(n_symbols):
        if exists[i] and valid[i] and not any(np.isnan([o[i], h[i], l[i], c[i]])):
            body = self._body_size(o[i], c[i])
            upper_shadow = self._upper_shadow(o[i], h[i], c[i])
            lower_shadow = self._lower_shadow(o[i], l[i], c[i])

            if body > 0:
                if upper_shadow >= 2 * body and lower_shadow <= body * 0.3:
                    result[i] = -100.0

    result_valid = exists & valid
    return TaggedArray(
        value=result,
        exists=exists,
        valid=result_valid,
        updated=np.ones(n_symbols, dtype=bool),
    )

_{Source: apps/trading/operators/indicator/patterns.py}

---

CDLENGULFING

Engulfing Pattern - Strong reversal signal.

Example: pattern = CDLENGULFING( Input(“FIELD:open”, timeframe=“1m”, lookback=5), Input(“FIELD:high”, timeframe=“1m”, lookback=5), Input(“FIELD:low”, timeframe=“1m”, lookback=5), Input(“FIELD:close”, timeframe=“1m”, lookback=5), )

Role: INDICATOR | Ephemeral: No

Parameters

Parameter	Type	Default	Description
open_	'Input'	Required
high	'Input'	Required
low	'Input'	Required
close	'Input'	Required

Usage

pattern = CDLENGULFING(
    Input("FIELD:open", timeframe="1m", lookback=5),
    Input("FIELD:high", timeframe="1m", lookback=5),
    Input("FIELD:low", timeframe="1m", lookback=5),
    Input("FIELD:close", timeframe="1m", lookback=5),
)

Source Code

Full compute() implementation — no hidden logic.

def compute(self, data, timestamp=None, context=None) -> TaggedArray:
    if not isinstance(data, list) or len(data) < 4:
        return self._empty_output()

    n_time = len(data[0])
    if n_time < 2:
        return self._empty_output()

    o1, h1, l1, c1 = self._get_ohlc(data, -2)  # Previous candle
    o2, h2, l2, c2 = self._get_ohlc(data, -1)  # Current candle

    n_symbols = len(o2)
    exists = data[3][-1].exists
    valid = data[3][-1].valid
    result = np.zeros(n_symbols)

    for i in range(n_symbols):
        if exists[i] and valid[i] and not any(np.isnan([o1[i], c1[i], o2[i], c2[i]])):
            # Bullish engulfing: prev bearish, current bullish that engulfs
            if self._is_bearish(o1[i], c1[i]) and self._is_bullish(o2[i], c2[i]):
                if o2[i] <= c1[i] and c2[i] >= o1[i]:
                    result[i] = 100.0

            # Bearish engulfing: prev bullish, current bearish that engulfs
            elif self._is_bullish(o1[i], c1[i]) and self._is_bearish(o2[i], c2[i]):
                if o2[i] >= c1[i] and c2[i] <= o1[i]:
                    result[i] = -100.0

    result_valid = exists & valid
    return TaggedArray(
        value=result,
        exists=exists,
        valid=result_valid,
        updated=np.ones(n_symbols, dtype=bool),
    )

_{Source: apps/trading/operators/indicator/patterns.py}

---

CDLHARAMI

Harami Pattern - Potential reversal.

Example: pattern = CDLHARAMI( Input(“FIELD:open”, timeframe=“1m”, lookback=5), Input(“FIELD:high”, timeframe=“1m”, lookback=5), Input(“FIELD:low”, timeframe=“1m”, lookback=5), Input(“FIELD:close”, timeframe=“1m”, lookback=5), )

Role: INDICATOR | Ephemeral: No

Parameters

Parameter	Type	Default	Description
open_	'Input'	Required
high	'Input'	Required
low	'Input'	Required
close	'Input'	Required

Usage

pattern = CDLHARAMI(
    Input("FIELD:open", timeframe="1m", lookback=5),
    Input("FIELD:high", timeframe="1m", lookback=5),
    Input("FIELD:low", timeframe="1m", lookback=5),
    Input("FIELD:close", timeframe="1m", lookback=5),
)

Source Code

Full compute() implementation — no hidden logic.

def compute(self, data, timestamp=None, context=None) -> TaggedArray:
    if not isinstance(data, list) or len(data) < 4:
        return self._empty_output()

    n_time = len(data[0])
    if n_time < 2:
        return self._empty_output()

    o1, h1, l1, c1 = self._get_ohlc(data, -2)
    o2, h2, l2, c2 = self._get_ohlc(data, -1)

    n_symbols = len(o2)
    exists = data[3][-1].exists
    valid = data[3][-1].valid
    result = np.zeros(n_symbols)

    for i in range(n_symbols):
        if exists[i] and valid[i] and not any(np.isnan([o1[i], c1[i], o2[i], c2[i]])):
            # Bullish harami: prev bearish, current small bullish inside
            if self._is_bearish(o1[i], c1[i]) and self._is_bullish(o2[i], c2[i]):
                if o2[i] >= c1[i] and c2[i] <= o1[i]:
                    result[i] = 100.0

            # Bearish harami: prev bullish, current small bearish inside
            elif self._is_bullish(o1[i], c1[i]) and self._is_bearish(o2[i], c2[i]):
                if o2[i] <= c1[i] and c2[i] >= o1[i]:
                    result[i] = -100.0

    result_valid = exists & valid
    return TaggedArray(
        value=result,
        exists=exists,
        valid=result_valid,
        updated=np.ones(n_symbols, dtype=bool),
    )

_{Source: apps/trading/operators/indicator/patterns.py}

---

CDLMORNINGSTAR

Morning Star - Bullish three-candle reversal.

Example: pattern = CDLMORNINGSTAR( Input(“FIELD:open”, timeframe=“1m”, lookback=5), Input(“FIELD:high”, timeframe=“1m”, lookback=5), Input(“FIELD:low”, timeframe=“1m”, lookback=5), Input(“FIELD:close”, timeframe=“1m”, lookback=5), )

Role: INDICATOR | Ephemeral: No

Parameters

Parameter	Type	Default	Description
open_	'Input'	Required
high	'Input'	Required
low	'Input'	Required
close	'Input'	Required

Usage

pattern = CDLMORNINGSTAR(
    Input("FIELD:open", timeframe="1m", lookback=5),
    Input("FIELD:high", timeframe="1m", lookback=5),
    Input("FIELD:low", timeframe="1m", lookback=5),
    Input("FIELD:close", timeframe="1m", lookback=5),
)

Source Code

Full compute() implementation — no hidden logic.

def compute(self, data, timestamp=None, context=None) -> TaggedArray:
    if not isinstance(data, list) or len(data) < 4:
        return self._empty_output()

    n_time = len(data[0])
    if n_time < 3:
        return self._empty_output()

    o1, h1, l1, c1 = self._get_ohlc(data, -3)
    o2, h2, l2, c2 = self._get_ohlc(data, -2)
    o3, h3, l3, c3 = self._get_ohlc(data, -1)

    n_symbols = len(o3)
    exists = data[3][-1].exists
    valid = data[3][-1].valid
    result = np.zeros(n_symbols)

    for i in range(n_symbols):
        if exists[i] and valid[i]:
            if any(np.isnan([o1[i], c1[i], o2[i], c2[i], o3[i], c3[i]])):
                continue

            body1 = self._body_size(o1[i], c1[i])
            body2 = self._body_size(o2[i], c2[i])
            body3 = self._body_size(o3[i], c3[i])

            # First: long bearish, Second: small body (star), Third: long bullish
            if (self._is_bearish(o1[i], c1[i]) and
                body2 < body1 * 0.3 and
                self._is_bullish(o3[i], c3[i]) and
                c3[i] > (o1[i] + c1[i]) / 2):  # Closes above midpoint of first
                result[i] = 100.0

    result_valid = exists & valid
    return TaggedArray(
        value=result,
        exists=exists,
        valid=result_valid,
        updated=np.ones(n_symbols, dtype=bool),
    )

_{Source: apps/trading/operators/indicator/patterns.py}

---

CDLEVENINGSTAR

Evening Star - Bearish three-candle reversal.

Example: pattern = CDLEVENINGSTAR( Input(“FIELD:open”, timeframe=“1m”, lookback=5), Input(“FIELD:high”, timeframe=“1m”, lookback=5), Input(“FIELD:low”, timeframe=“1m”, lookback=5), Input(“FIELD:close”, timeframe=“1m”, lookback=5), )

Role: INDICATOR | Ephemeral: No

Parameters

Parameter	Type	Default	Description
open_	'Input'	Required
high	'Input'	Required
low	'Input'	Required
close	'Input'	Required

Usage

pattern = CDLEVENINGSTAR(
    Input("FIELD:open", timeframe="1m", lookback=5),
    Input("FIELD:high", timeframe="1m", lookback=5),
    Input("FIELD:low", timeframe="1m", lookback=5),
    Input("FIELD:close", timeframe="1m", lookback=5),
)

Source Code

Full compute() implementation — no hidden logic.

def compute(self, data, timestamp=None, context=None) -> TaggedArray:
    if not isinstance(data, list) or len(data) < 4:
        return self._empty_output()

    n_time = len(data[0])
    if n_time < 3:
        return self._empty_output()

    o1, h1, l1, c1 = self._get_ohlc(data, -3)
    o2, h2, l2, c2 = self._get_ohlc(data, -2)
    o3, h3, l3, c3 = self._get_ohlc(data, -1)

    n_symbols = len(o3)
    exists = data[3][-1].exists
    valid = data[3][-1].valid
    result = np.zeros(n_symbols)

    for i in range(n_symbols):
        if exists[i] and valid[i]:
            if any(np.isnan([o1[i], c1[i], o2[i], c2[i], o3[i], c3[i]])):
                continue

            body1 = self._body_size(o1[i], c1[i])
            body2 = self._body_size(o2[i], c2[i])

            # First: long bullish, Second: small body (star), Third: long bearish
            if (self._is_bullish(o1[i], c1[i]) and
                body2 < body1 * 0.3 and
                self._is_bearish(o3[i], c3[i]) and
                c3[i] < (o1[i] + c1[i]) / 2):
                result[i] = -100.0

    result_valid = exists & valid
    return TaggedArray(
        value=result,
        exists=exists,
        valid=result_valid,
        updated=np.ones(n_symbols, dtype=bool),
    )

_{Source: apps/trading/operators/indicator/patterns.py}

---

CDLMARUBOZU

Marubozu - Strong candle with no shadows.

Example: pattern = CDLMARUBOZU( Input(“FIELD:open”, timeframe=“1m”, lookback=5), Input(“FIELD:high”, timeframe=“1m”, lookback=5), Input(“FIELD:low”, timeframe=“1m”, lookback=5), Input(“FIELD:close”, timeframe=“1m”, lookback=5), )

Role: INDICATOR | Ephemeral: No

Parameters

Parameter	Type	Default	Description
open_	'Input'	Required
high	'Input'	Required
low	'Input'	Required
close	'Input'	Required

Usage

pattern = CDLMARUBOZU(
    Input("FIELD:open", timeframe="1m", lookback=5),
    Input("FIELD:high", timeframe="1m", lookback=5),
    Input("FIELD:low", timeframe="1m", lookback=5),
    Input("FIELD:close", timeframe="1m", lookback=5),
)

Source Code

Full compute() implementation — no hidden logic.

def compute(self, data, timestamp=None, context=None) -> TaggedArray:
    if not isinstance(data, list) or len(data) < 4:
        return self._empty_output()

    n_time = len(data[0])
    if n_time == 0:
        return self._empty_output()

    o, h, l, c = self._get_ohlc(data)
    n_symbols = len(o)
    exists = data[3][-1].exists
    valid = data[3][-1].valid
    result = np.zeros(n_symbols)

    for i in range(n_symbols):
        if exists[i] and valid[i] and not any(np.isnan([o[i], h[i], l[i], c[i]])):
            body = self._body_size(o[i], c[i])
            range_size = h[i] - l[i]

            if range_size > 0 and body / range_size > 0.95:  # Almost no shadows
                if self._is_bullish(o[i], c[i]):
                    result[i] = 100.0
                else:
                    result[i] = -100.0

    result_valid = exists & valid
    return TaggedArray(
        value=result,
        exists=exists,
        valid=result_valid,
        updated=np.ones(n_symbols, dtype=bool),
    )

_{Source: apps/trading/operators/indicator/patterns.py}

---

CDL3WHITESOLDIERS

Three White Soldiers - Bullish continuation.

Example: pattern = CDL3WHITESOLDIERS( Input(“FIELD:open”, timeframe=“1m”, lookback=5), Input(“FIELD:high”, timeframe=“1m”, lookback=5), Input(“FIELD:low”, timeframe=“1m”, lookback=5), Input(“FIELD:close”, timeframe=“1m”, lookback=5), )

Role: INDICATOR | Ephemeral: No

Parameters

Parameter	Type	Default	Description
open_	'Input'	Required
high	'Input'	Required
low	'Input'	Required
close	'Input'	Required

Usage

pattern = CDL3WHITESOLDIERS(
    Input("FIELD:open", timeframe="1m", lookback=5),
    Input("FIELD:high", timeframe="1m", lookback=5),
    Input("FIELD:low", timeframe="1m", lookback=5),
    Input("FIELD:close", timeframe="1m", lookback=5),
)

Source Code

Full compute() implementation — no hidden logic.

def compute(self, data, timestamp=None, context=None) -> TaggedArray:
    if not isinstance(data, list) or len(data) < 4:
        return self._empty_output()

    n_time = len(data[0])
    if n_time < 3:
        return self._empty_output()

    o1, h1, l1, c1 = self._get_ohlc(data, -3)
    o2, h2, l2, c2 = self._get_ohlc(data, -2)
    o3, h3, l3, c3 = self._get_ohlc(data, -1)

    n_symbols = len(o3)
    exists = data[3][-1].exists
    valid = data[3][-1].valid
    result = np.zeros(n_symbols)

    for i in range(n_symbols):
        if exists[i] and valid[i]:
            if any(np.isnan([o1[i], c1[i], o2[i], c2[i], o3[i], c3[i]])):
                continue

            # Three consecutive bullish candles with higher closes
            if (self._is_bullish(o1[i], c1[i]) and
                self._is_bullish(o2[i], c2[i]) and
                self._is_bullish(o3[i], c3[i]) and
                c2[i] > c1[i] and c3[i] > c2[i]):
                result[i] = 100.0

    result_valid = exists & valid
    return TaggedArray(
        value=result,
        exists=exists,
        valid=result_valid,
        updated=np.ones(n_symbols, dtype=bool),
    )

_{Source: apps/trading/operators/indicator/patterns.py}

---

CDL3BLACKCROWS

Three Black Crows - Bearish continuation.

Example: pattern = CDL3BLACKCROWS( Input(“FIELD:open”, timeframe=“1m”, lookback=5), Input(“FIELD:high”, timeframe=“1m”, lookback=5), Input(“FIELD:low”, timeframe=“1m”, lookback=5), Input(“FIELD:close”, timeframe=“1m”, lookback=5), )

Role: INDICATOR | Ephemeral: No

Parameters

Parameter	Type	Default	Description
open_	'Input'	Required
high	'Input'	Required
low	'Input'	Required
close	'Input'	Required

Usage

pattern = CDL3BLACKCROWS(
    Input("FIELD:open", timeframe="1m", lookback=5),
    Input("FIELD:high", timeframe="1m", lookback=5),
    Input("FIELD:low", timeframe="1m", lookback=5),
    Input("FIELD:close", timeframe="1m", lookback=5),
)

Source Code

Full compute() implementation — no hidden logic.

def compute(self, data, timestamp=None, context=None) -> TaggedArray:
    if not isinstance(data, list) or len(data) < 4:
        return self._empty_output()

    n_time = len(data[0])
    if n_time < 3:
        return self._empty_output()

    o1, h1, l1, c1 = self._get_ohlc(data, -3)
    o2, h2, l2, c2 = self._get_ohlc(data, -2)
    o3, h3, l3, c3 = self._get_ohlc(data, -1)

    n_symbols = len(o3)
    exists = data[3][-1].exists
    valid = data[3][-1].valid
    result = np.zeros(n_symbols)

    for i in range(n_symbols):
        if exists[i] and valid[i]:
            if any(np.isnan([o1[i], c1[i], o2[i], c2[i], o3[i], c3[i]])):
                continue

            # Three consecutive bearish candles with lower closes
            if (self._is_bearish(o1[i], c1[i]) and
                self._is_bearish(o2[i], c2[i]) and
                self._is_bearish(o3[i], c3[i]) and
                c2[i] < c1[i] and c3[i] < c2[i]):
                result[i] = -100.0

    result_valid = exists & valid
    return TaggedArray(
        value=result,
        exists=exists,
        valid=result_valid,
        updated=np.ones(n_symbols, dtype=bool),
    )

_{Source: apps/trading/operators/indicator/patterns.py}

---

CDL2CROWS

Two Crows - Bearish reversal pattern.

Example: pattern = CDL2CROWS( Input(“FIELD:open”, timeframe=“1m”, lookback=5), Input(“FIELD:high”, timeframe=“1m”, lookback=5), Input(“FIELD:low”, timeframe=“1m”, lookback=5), Input(“FIELD:close”, timeframe=“1m”, lookback=5), )

Role: INDICATOR | Ephemeral: No

Parameters

Parameter	Type	Default	Description
open_	'Input'	Required
high	'Input'	Required
low	'Input'	Required
close	'Input'	Required

Usage

pattern = CDL2CROWS(
    Input("FIELD:open", timeframe="1m", lookback=5),
    Input("FIELD:high", timeframe="1m", lookback=5),
    Input("FIELD:low", timeframe="1m", lookback=5),
    Input("FIELD:close", timeframe="1m", lookback=5),
)

Source Code

Full compute() implementation — no hidden logic.

def compute(self, data, timestamp=None, context=None) -> TaggedArray:
    if not isinstance(data, list) or len(data) < 4:
        return self._empty_output()

    n_time = len(data[0])
    if n_time < 3:
        return self._empty_output()

    o1, h1, l1, c1 = self._get_ohlc(data, -3)
    o2, h2, l2, c2 = self._get_ohlc(data, -2)
    o3, h3, l3, c3 = self._get_ohlc(data, -1)

    n_symbols = len(o3)
    exists = data[3][-1].exists
    valid = data[3][-1].valid
    result = np.zeros(n_symbols)

    for i in range(n_symbols):
        if exists[i] and valid[i]:
            if any(np.isnan([o1[i], c1[i], o2[i], c2[i], o3[i], c3[i]])):
                continue
            # First: long bullish, Second: small bearish gap up, Third: bearish engulfs second
            if (self._is_bullish(o1[i], c1[i]) and
                self._is_bearish(o2[i], c2[i]) and o2[i] > c1[i] and
                self._is_bearish(o3[i], c3[i]) and o3[i] > o2[i] and c3[i] < c2[i]):
                result[i] = -100.0

    result_valid = exists & valid
    return TaggedArray(
        value=result,
        exists=exists,
        valid=result_valid,
        updated=np.ones(n_symbols, dtype=bool),
    )

_{Source: apps/trading/operators/indicator/patterns.py}

---

CDL3INSIDE

Three Inside Up/Down - Reversal pattern.

Example: pattern = CDL3INSIDE( Input(“FIELD:open”, timeframe=“1m”, lookback=5), Input(“FIELD:high”, timeframe=“1m”, lookback=5), Input(“FIELD:low”, timeframe=“1m”, lookback=5), Input(“FIELD:close”, timeframe=“1m”, lookback=5), )

Role: INDICATOR | Ephemeral: No

Parameters

Parameter	Type	Default	Description
open_	'Input'	Required
high	'Input'	Required
low	'Input'	Required
close	'Input'	Required

Usage

pattern = CDL3INSIDE(
    Input("FIELD:open", timeframe="1m", lookback=5),
    Input("FIELD:high", timeframe="1m", lookback=5),
    Input("FIELD:low", timeframe="1m", lookback=5),
    Input("FIELD:close", timeframe="1m", lookback=5),
)

Source Code

Full compute() implementation — no hidden logic.

def compute(self, data, timestamp=None, context=None) -> TaggedArray:
    if not isinstance(data, list) or len(data) < 4:
        return self._empty_output()

    n_time = len(data[0])
    if n_time < 3:
        return self._empty_output()

    o1, h1, l1, c1 = self._get_ohlc(data, -3)
    o2, h2, l2, c2 = self._get_ohlc(data, -2)
    o3, h3, l3, c3 = self._get_ohlc(data, -1)

    n_symbols = len(o3)
    exists = data[3][-1].exists
    valid = data[3][-1].valid
    result = np.zeros(n_symbols)

    for i in range(n_symbols):
        if exists[i] and valid[i]:
            if any(np.isnan([o1[i], c1[i], o2[i], c2[i], o3[i], c3[i]])):
                continue
            # Three Inside Up: bearish, bullish harami, bullish confirmation
            if (self._is_bearish(o1[i], c1[i]) and
                self._is_bullish(o2[i], c2[i]) and o2[i] > c1[i] and c2[i] < o1[i] and
                self._is_bullish(o3[i], c3[i]) and c3[i] > c2[i]):
                result[i] = 100.0
            # Three Inside Down: bullish, bearish harami, bearish confirmation
            elif (self._is_bullish(o1[i], c1[i]) and
                  self._is_bearish(o2[i], c2[i]) and o2[i] < c1[i] and c2[i] > o1[i] and
                  self._is_bearish(o3[i], c3[i]) and c3[i] < c2[i]):
                result[i] = -100.0

    result_valid = exists & valid
    return TaggedArray(
        value=result,
        exists=exists,
        valid=result_valid,
        updated=np.ones(n_symbols, dtype=bool),
    )

_{Source: apps/trading/operators/indicator/patterns.py}

---

CDL3LINESTRIKE

Three-Line Strike - Continuation pattern.

Example: pattern = CDL3LINESTRIKE( Input(“FIELD:open”, timeframe=“1m”, lookback=5), Input(“FIELD:high”, timeframe=“1m”, lookback=5), Input(“FIELD:low”, timeframe=“1m”, lookback=5), Input(“FIELD:close”, timeframe=“1m”, lookback=5), )

Role: INDICATOR | Ephemeral: No

Parameters

Parameter	Type	Default	Description
open_	'Input'	Required
high	'Input'	Required
low	'Input'	Required
close	'Input'	Required

Usage

pattern = CDL3LINESTRIKE(
    Input("FIELD:open", timeframe="1m", lookback=5),
    Input("FIELD:high", timeframe="1m", lookback=5),
    Input("FIELD:low", timeframe="1m", lookback=5),
    Input("FIELD:close", timeframe="1m", lookback=5),
)

Source Code

Full compute() implementation — no hidden logic.

def compute(self, data, timestamp=None, context=None) -> TaggedArray:
    if not isinstance(data, list) or len(data) < 4:
        return self._empty_output()

    n_time = len(data[0])
    if n_time < 4:
        return self._empty_output()

    o1, h1, l1, c1 = self._get_ohlc(data, -4)
    o2, h2, l2, c2 = self._get_ohlc(data, -3)
    o3, h3, l3, c3 = self._get_ohlc(data, -2)
    o4, h4, l4, c4 = self._get_ohlc(data, -1)

    n_symbols = len(o4)
    exists = data[3][-1].exists
    valid = data[3][-1].valid
    result = np.zeros(n_symbols)

    for i in range(n_symbols):
        if exists[i] and valid[i]:
            if any(np.isnan([o1[i], c1[i], o2[i], c2[i], o3[i], c3[i], o4[i], c4[i]])):
                continue
            # Bullish: three bearish + one bullish that engulfs all
            if (self._is_bearish(o1[i], c1[i]) and self._is_bearish(o2[i], c2[i]) and
                self._is_bearish(o3[i], c3[i]) and c2[i] < c1[i] and c3[i] < c2[i] and
                self._is_bullish(o4[i], c4[i]) and o4[i] < c3[i] and c4[i] > o1[i]):
                result[i] = 100.0
            # Bearish: three bullish + one bearish
            elif (self._is_bullish(o1[i], c1[i]) and self._is_bullish(o2[i], c2[i]) and
                  self._is_bullish(o3[i], c3[i]) and c2[i] > c1[i] and c3[i] > c2[i] and
                  self._is_bearish(o4[i], c4[i]) and o4[i] > c3[i] and c4[i] < o1[i]):
                result[i] = -100.0

    result_valid = exists & valid
    return TaggedArray(
        value=result,
        exists=exists,
        valid=result_valid,
        updated=np.ones(n_symbols, dtype=bool),
    )

_{Source: apps/trading/operators/indicator/patterns.py}

---

CDL3STARSINSOUTH

Three Stars In The South - Bullish reversal.

Example: pattern = CDL3STARSINSOUTH( Input(“FIELD:open”, timeframe=“1m”, lookback=5), Input(“FIELD:high”, timeframe=“1m”, lookback=5), Input(“FIELD:low”, timeframe=“1m”, lookback=5), Input(“FIELD:close”, timeframe=“1m”, lookback=5), )

Role: INDICATOR | Ephemeral: No

Parameters

Parameter	Type	Default	Description
open_	'Input'	Required
high	'Input'	Required
low	'Input'	Required
close	'Input'	Required

Usage

pattern = CDL3STARSINSOUTH(
    Input("FIELD:open", timeframe="1m", lookback=5),
    Input("FIELD:high", timeframe="1m", lookback=5),
    Input("FIELD:low", timeframe="1m", lookback=5),
    Input("FIELD:close", timeframe="1m", lookback=5),
)

Source Code

Full compute() implementation — no hidden logic.

def compute(self, data, timestamp=None, context=None) -> TaggedArray:
    if not isinstance(data, list) or len(data) < 4:
        return self._empty_output()

    n_time = len(data[0])
    if n_time < 3:
        return self._empty_output()

    o1, h1, l1, c1 = self._get_ohlc(data, -3)
    o2, h2, l2, c2 = self._get_ohlc(data, -2)
    o3, h3, l3, c3 = self._get_ohlc(data, -1)

    n_symbols = len(o3)
    exists = data[3][-1].exists
    valid = data[3][-1].valid
    result = np.zeros(n_symbols)

    for i in range(n_symbols):
        if exists[i] and valid[i]:
            if any(np.isnan([o1[i], c1[i], o2[i], c2[i], o3[i], c3[i]])):
                continue
            # Three decreasing bearish candles
            body1 = self._body_size(o1[i], c1[i])
            body2 = self._body_size(o2[i], c2[i])
            body3 = self._body_size(o3[i], c3[i])
            if (self._is_bearish(o1[i], c1[i]) and self._is_bearish(o2[i], c2[i]) and
                self._is_bearish(o3[i], c3[i]) and body2 < body1 and body3 < body2):
                result[i] = 100.0

    result_valid = exists & valid
    return TaggedArray(
        value=result,
        exists=exists,
        valid=result_valid,
        updated=np.ones(n_symbols, dtype=bool),
    )

_{Source: apps/trading/operators/indicator/patterns.py}

---

CDLABANDONEDBABY

Abandoned Baby - Strong reversal pattern with gaps.

Example: pattern = CDLABANDONEDBABY( Input(“FIELD:open”, timeframe=“1m”, lookback=5), Input(“FIELD:high”, timeframe=“1m”, lookback=5), Input(“FIELD:low”, timeframe=“1m”, lookback=5), Input(“FIELD:close”, timeframe=“1m”, lookback=5), )

Role: INDICATOR | Ephemeral: No

Parameters

Parameter	Type	Default	Description
open_	'Input'	Required
high	'Input'	Required
low	'Input'	Required
close	'Input'	Required

Usage

pattern = CDLABANDONEDBABY(
    Input("FIELD:open", timeframe="1m", lookback=5),
    Input("FIELD:high", timeframe="1m", lookback=5),
    Input("FIELD:low", timeframe="1m", lookback=5),
    Input("FIELD:close", timeframe="1m", lookback=5),
)

Source Code

Full compute() implementation — no hidden logic.

def compute(self, data, timestamp=None, context=None) -> TaggedArray:
    if not isinstance(data, list) or len(data) < 4:
        return self._empty_output()

    n_time = len(data[0])
    if n_time < 3:
        return self._empty_output()

    o1, h1, l1, c1 = self._get_ohlc(data, -3)
    o2, h2, l2, c2 = self._get_ohlc(data, -2)
    o3, h3, l3, c3 = self._get_ohlc(data, -1)

    n_symbols = len(o3)
    exists = data[3][-1].exists
    valid = data[3][-1].valid
    result = np.zeros(n_symbols)

    for i in range(n_symbols):
        if exists[i] and valid[i]:
            if any(np.isnan([o1[i], h1[i], l1[i], c1[i], o2[i], h2[i], l2[i], c2[i], o3[i], c3[i]])):
                continue
            body2 = self._body_size(o2[i], c2[i])
            range2 = h2[i] - l2[i]
            is_doji = range2 > 0 and body2 / range2 < 0.1

            # Bullish: bearish, doji gap down, bullish gap up
            if (self._is_bearish(o1[i], c1[i]) and is_doji and h2[i] < l1[i] and
                self._is_bullish(o3[i], c3[i]) and l3[i] > h2[i]):
                result[i] = 100.0
            # Bearish: bullish, doji gap up, bearish gap down
            elif (self._is_bullish(o1[i], c1[i]) and is_doji and l2[i] > h1[i] and
                  self._is_bearish(o3[i], c3[i]) and h3[i] < l2[i]):
                result[i] = -100.0

    result_valid = exists & valid
    return TaggedArray(
        value=result,
        exists=exists,
        valid=result_valid,
        updated=np.ones(n_symbols, dtype=bool),
    )

_{Source: apps/trading/operators/indicator/patterns.py}

---

CDLADVANCEBLOCK

Advance Block - Bearish reversal with weakening bulls.

Example: pattern = CDLADVANCEBLOCK( Input(“FIELD:open”, timeframe=“1m”, lookback=5), Input(“FIELD:high”, timeframe=“1m”, lookback=5), Input(“FIELD:low”, timeframe=“1m”, lookback=5), Input(“FIELD:close”, timeframe=“1m”, lookback=5), )

Role: INDICATOR | Ephemeral: No

Parameters

Parameter	Type	Default	Description
open_	'Input'	Required
high	'Input'	Required
low	'Input'	Required
close	'Input'	Required

Usage

pattern = CDLADVANCEBLOCK(
    Input("FIELD:open", timeframe="1m", lookback=5),
    Input("FIELD:high", timeframe="1m", lookback=5),
    Input("FIELD:low", timeframe="1m", lookback=5),
    Input("FIELD:close", timeframe="1m", lookback=5),
)

Source Code

Full compute() implementation — no hidden logic.

def compute(self, data, timestamp=None, context=None) -> TaggedArray:
    if not isinstance(data, list) or len(data) < 4:
        return self._empty_output()

    n_time = len(data[0])
    if n_time < 3:
        return self._empty_output()

    o1, h1, l1, c1 = self._get_ohlc(data, -3)
    o2, h2, l2, c2 = self._get_ohlc(data, -2)
    o3, h3, l3, c3 = self._get_ohlc(data, -1)

    n_symbols = len(o3)
    exists = data[3][-1].exists
    valid = data[3][-1].valid
    result = np.zeros(n_symbols)

    for i in range(n_symbols):
        if exists[i] and valid[i]:
            if any(np.isnan([o1[i], c1[i], o2[i], c2[i], o3[i], c3[i]])):
                continue
            body1 = self._body_size(o1[i], c1[i])
            body2 = self._body_size(o2[i], c2[i])
            body3 = self._body_size(o3[i], c3[i])
            # Three bullish with decreasing bodies
            if (self._is_bullish(o1[i], c1[i]) and self._is_bullish(o2[i], c2[i]) and
                self._is_bullish(o3[i], c3[i]) and body2 < body1 and body3 < body2 and
                c2[i] > c1[i] and c3[i] > c2[i]):
                result[i] = -100.0

    result_valid = exists & valid
    return TaggedArray(
        value=result,
        exists=exists,
        valid=result_valid,
        updated=np.ones(n_symbols, dtype=bool),
    )

_{Source: apps/trading/operators/indicator/patterns.py}

---

CDLBELTHOLD

Belt-hold - Single candle reversal pattern.

Example: pattern = CDLBELTHOLD( Input(“FIELD:open”, timeframe=“1m”, lookback=5), Input(“FIELD:high”, timeframe=“1m”, lookback=5), Input(“FIELD:low”, timeframe=“1m”, lookback=5), Input(“FIELD:close”, timeframe=“1m”, lookback=5), )

Role: INDICATOR | Ephemeral: No

Parameters

Parameter	Type	Default	Description
open_	'Input'	Required
high	'Input'	Required
low	'Input'	Required
close	'Input'	Required

Usage

pattern = CDLBELTHOLD(
    Input("FIELD:open", timeframe="1m", lookback=5),
    Input("FIELD:high", timeframe="1m", lookback=5),
    Input("FIELD:low", timeframe="1m", lookback=5),
    Input("FIELD:close", timeframe="1m", lookback=5),
)

Source Code

Full compute() implementation — no hidden logic.

def compute(self, data, timestamp=None, context=None) -> TaggedArray:
    if not isinstance(data, list) or len(data) < 4:
        return self._empty_output()

    n_time = len(data[0])
    if n_time == 0:
        return self._empty_output()

    o, h, l, c = self._get_ohlc(data)
    n_symbols = len(o)
    exists = data[3][-1].exists
    valid = data[3][-1].valid
    result = np.zeros(n_symbols)

    for i in range(n_symbols):
        if exists[i] and valid[i] and not any(np.isnan([o[i], h[i], l[i], c[i]])):
            body = self._body_size(o[i], c[i])
            range_size = h[i] - l[i]
            if range_size > 0 and body / range_size > 0.6:
                # Bullish belt hold: opens at low
                if self._is_bullish(o[i], c[i]) and abs(o[i] - l[i]) < range_size * 0.05:
                    result[i] = 100.0
                # Bearish belt hold: opens at high
                elif self._is_bearish(o[i], c[i]) and abs(o[i] - h[i]) < range_size * 0.05:
                    result[i] = -100.0

    result_valid = exists & valid
    return TaggedArray(
        value=result,
        exists=exists,
        valid=result_valid,
        updated=np.ones(n_symbols, dtype=bool),
    )

_{Source: apps/trading/operators/indicator/patterns.py}

---

CDLBREAKAWAY

Breakaway - Five candle reversal pattern.

Example: pattern = CDLBREAKAWAY( Input(“FIELD:open”, timeframe=“1m”, lookback=5), Input(“FIELD:high”, timeframe=“1m”, lookback=5), Input(“FIELD:low”, timeframe=“1m”, lookback=5), Input(“FIELD:close”, timeframe=“1m”, lookback=5), )

Role: INDICATOR | Ephemeral: No

Parameters

Parameter	Type	Default	Description
open_	'Input'	Required
high	'Input'	Required
low	'Input'	Required
close	'Input'	Required

Usage

pattern = CDLBREAKAWAY(
    Input("FIELD:open", timeframe="1m", lookback=5),
    Input("FIELD:high", timeframe="1m", lookback=5),
    Input("FIELD:low", timeframe="1m", lookback=5),
    Input("FIELD:close", timeframe="1m", lookback=5),
)

Source Code

Full compute() implementation — no hidden logic.

def compute(self, data, timestamp=None, context=None) -> TaggedArray:
    if not isinstance(data, list) or len(data) < 4:
        return self._empty_output()

    n_time = len(data[0])
    if n_time < 5:
        return self._empty_output()

    n_symbols = len(data[0][-1].value)
    exists = data[3][-1].exists
    valid = data[3][-1].valid
    result = np.zeros(n_symbols)

    ohlc = [self._get_ohlc(data, -5+j) for j in range(5)]

    for i in range(n_symbols):
        if exists[i] and valid[i]:
            o = [ohlc[j][0][i] for j in range(5)]
            c = [ohlc[j][3][i] for j in range(5)]
            if any(np.isnan(o + c)):
                continue
            # Simplified: strong move then reversal
            if (self._is_bearish(o[0], c[0]) and c[1] < c[0] and c[2] < c[1] and
                self._is_bullish(o[4], c[4]) and c[4] > c[0]):
                result[i] = 100.0
            elif (self._is_bullish(o[0], c[0]) and c[1] > c[0] and c[2] > c[1] and
                  self._is_bearish(o[4], c[4]) and c[4] < c[0]):
                result[i] = -100.0

    result_valid = exists & valid
    return TaggedArray(
        value=result,
        exists=exists,
        valid=result_valid,
        updated=np.ones(n_symbols, dtype=bool),
    )

_{Source: apps/trading/operators/indicator/patterns.py}

---

CDLCLOSINGMARUBOZU

Closing Marubozu - No shadow on closing side.

Example: pattern = CDLCLOSINGMARUBOZU( Input(“FIELD:open”, timeframe=“1m”, lookback=5), Input(“FIELD:high”, timeframe=“1m”, lookback=5), Input(“FIELD:low”, timeframe=“1m”, lookback=5), Input(“FIELD:close”, timeframe=“1m”, lookback=5), )

Role: INDICATOR | Ephemeral: No

Parameters

Parameter	Type	Default	Description
open_	'Input'	Required
high	'Input'	Required
low	'Input'	Required
close	'Input'	Required

Usage

pattern = CDLCLOSINGMARUBOZU(
    Input("FIELD:open", timeframe="1m", lookback=5),
    Input("FIELD:high", timeframe="1m", lookback=5),
    Input("FIELD:low", timeframe="1m", lookback=5),
    Input("FIELD:close", timeframe="1m", lookback=5),
)

Source Code

Full compute() implementation — no hidden logic.

def compute(self, data, timestamp=None, context=None) -> TaggedArray:
    if not isinstance(data, list) or len(data) < 4:
        return self._empty_output()

    n_time = len(data[0])
    if n_time == 0:
        return self._empty_output()

    o, h, l, c = self._get_ohlc(data)
    n_symbols = len(o)
    exists = data[3][-1].exists
    valid = data[3][-1].valid
    result = np.zeros(n_symbols)

    for i in range(n_symbols):
        if exists[i] and valid[i] and not any(np.isnan([o[i], h[i], l[i], c[i]])):
            range_size = h[i] - l[i]
            if range_size > 0:
                if self._is_bullish(o[i], c[i]) and abs(c[i] - h[i]) < range_size * 0.02:
                    result[i] = 100.0
                elif self._is_bearish(o[i], c[i]) and abs(c[i] - l[i]) < range_size * 0.02:
                    result[i] = -100.0

    result_valid = exists & valid
    return TaggedArray(
        value=result,
        exists=exists,
        valid=result_valid,
        updated=np.ones(n_symbols, dtype=bool),
    )

_{Source: apps/trading/operators/indicator/patterns.py}

---

CDLCONCEALBABYSWALL

Concealing Baby Swallow - Rare bullish reversal.

Example: pattern = CDLCONCEALBABYSWALL( Input(“FIELD:open”, timeframe=“1m”, lookback=5), Input(“FIELD:high”, timeframe=“1m”, lookback=5), Input(“FIELD:low”, timeframe=“1m”, lookback=5), Input(“FIELD:close”, timeframe=“1m”, lookback=5), )

Role: INDICATOR | Ephemeral: No

Parameters

Parameter	Type	Default	Description
open_	'Input'	Required
high	'Input'	Required
low	'Input'	Required
close	'Input'	Required

Usage

pattern = CDLCONCEALBABYSWALL(
    Input("FIELD:open", timeframe="1m", lookback=5),
    Input("FIELD:high", timeframe="1m", lookback=5),
    Input("FIELD:low", timeframe="1m", lookback=5),
    Input("FIELD:close", timeframe="1m", lookback=5),
)

Source Code

Full compute() implementation — no hidden logic.

def compute(self, data, timestamp=None, context=None) -> TaggedArray:
    if not isinstance(data, list) or len(data) < 4:
        return self._empty_output()

    n_time = len(data[0])
    if n_time < 4:
        return self._empty_output()

    n_symbols = len(data[0][-1].value)
    exists = data[3][-1].exists
    valid = data[3][-1].valid
    result = np.zeros(n_symbols)

    ohlc = [self._get_ohlc(data, -4+j) for j in range(4)]

    for i in range(n_symbols):
        if exists[i] and valid[i]:
            o = [ohlc[j][0][i] for j in range(4)]
            h = [ohlc[j][1][i] for j in range(4)]
            l = [ohlc[j][2][i] for j in range(4)]
            c = [ohlc[j][3][i] for j in range(4)]
            if any(np.isnan(o + h + l + c)):
                continue
            # Four marubozu-like bearish, fourth engulfs
            all_bearish = all(self._is_bearish(o[j], c[j]) for j in range(4))
            if all_bearish and c[3] < c[0]:
                result[i] = 100.0

    result_valid = exists & valid
    return TaggedArray(
        value=result,
        exists=exists,
        valid=result_valid,
        updated=np.ones(n_symbols, dtype=bool),
    )

_{Source: apps/trading/operators/indicator/patterns.py}

---

CDLCOUNTERATTACK

Counterattack - Two candle reversal with equal closes.

Example: pattern = CDLCOUNTERATTACK( Input(“FIELD:open”, timeframe=“1m”, lookback=5), Input(“FIELD:high”, timeframe=“1m”, lookback=5), Input(“FIELD:low”, timeframe=“1m”, lookback=5), Input(“FIELD:close”, timeframe=“1m”, lookback=5), )

Role: INDICATOR | Ephemeral: No

Parameters

Parameter	Type	Default	Description
open_	'Input'	Required
high	'Input'	Required
low	'Input'	Required
close	'Input'	Required

Usage

pattern = CDLCOUNTERATTACK(
    Input("FIELD:open", timeframe="1m", lookback=5),
    Input("FIELD:high", timeframe="1m", lookback=5),
    Input("FIELD:low", timeframe="1m", lookback=5),
    Input("FIELD:close", timeframe="1m", lookback=5),
)

Source Code

Full compute() implementation — no hidden logic.

def compute(self, data, timestamp=None, context=None) -> TaggedArray:
    if not isinstance(data, list) or len(data) < 4:
        return self._empty_output()

    n_time = len(data[0])
    if n_time < 2:
        return self._empty_output()

    o1, h1, l1, c1 = self._get_ohlc(data, -2)
    o2, h2, l2, c2 = self._get_ohlc(data, -1)

    n_symbols = len(o2)
    exists = data[3][-1].exists
    valid = data[3][-1].valid
    result = np.zeros(n_symbols)

    for i in range(n_symbols):
        if exists[i] and valid[i] and not any(np.isnan([o1[i], c1[i], o2[i], c2[i]])):
            # Closes are approximately equal
            close_diff = abs(c1[i] - c2[i])
            avg_body = (self._body_size(o1[i], c1[i]) + self._body_size(o2[i], c2[i])) / 2
            if avg_body > 0 and close_diff / avg_body < 0.1:
                if self._is_bearish(o1[i], c1[i]) and self._is_bullish(o2[i], c2[i]):
                    result[i] = 100.0
                elif self._is_bullish(o1[i], c1[i]) and self._is_bearish(o2[i], c2[i]):
                    result[i] = -100.0

    result_valid = exists & valid
    return TaggedArray(
        value=result,
        exists=exists,
        valid=result_valid,
        updated=np.ones(n_symbols, dtype=bool),
    )

_{Source: apps/trading/operators/indicator/patterns.py}

---

CDLDARKCLOUDCOVER

Dark Cloud Cover - Bearish reversal.

Example: pattern = CDLDARKCLOUDCOVER( Input(“FIELD:open”, timeframe=“1m”, lookback=5), Input(“FIELD:high”, timeframe=“1m”, lookback=5), Input(“FIELD:low”, timeframe=“1m”, lookback=5), Input(“FIELD:close”, timeframe=“1m”, lookback=5), )

Role: INDICATOR | Ephemeral: No

Parameters

Parameter	Type	Default	Description
open_	'Input'	Required
high	'Input'	Required
low	'Input'	Required
close	'Input'	Required

Usage

pattern = CDLDARKCLOUDCOVER(
    Input("FIELD:open", timeframe="1m", lookback=5),
    Input("FIELD:high", timeframe="1m", lookback=5),
    Input("FIELD:low", timeframe="1m", lookback=5),
    Input("FIELD:close", timeframe="1m", lookback=5),
)

Source Code

Full compute() implementation — no hidden logic.

def compute(self, data, timestamp=None, context=None) -> TaggedArray:
    if not isinstance(data, list) or len(data) < 4:
        return self._empty_output()

    n_time = len(data[0])
    if n_time < 2:
        return self._empty_output()

    o1, h1, l1, c1 = self._get_ohlc(data, -2)
    o2, h2, l2, c2 = self._get_ohlc(data, -1)

    n_symbols = len(o2)
    exists = data[3][-1].exists
    valid = data[3][-1].valid
    result = np.zeros(n_symbols)

    for i in range(n_symbols):
        if exists[i] and valid[i] and not any(np.isnan([o1[i], c1[i], o2[i], c2[i]])):
            # Bullish first, bearish second opening above and closing below midpoint
            if (self._is_bullish(o1[i], c1[i]) and self._is_bearish(o2[i], c2[i]) and
                o2[i] > c1[i] and c2[i] < (o1[i] + c1[i]) / 2 and c2[i] > o1[i]):
                result[i] = -100.0

    result_valid = exists & valid
    return TaggedArray(
        value=result,
        exists=exists,
        valid=result_valid,
        updated=np.ones(n_symbols, dtype=bool),
    )

_{Source: apps/trading/operators/indicator/patterns.py}

---

CDLDOJISTAR

Doji Star - Reversal pattern with doji.

Example: pattern = CDLDOJISTAR( Input(“FIELD:open”, timeframe=“1m”, lookback=5), Input(“FIELD:high”, timeframe=“1m”, lookback=5), Input(“FIELD:low”, timeframe=“1m”, lookback=5), Input(“FIELD:close”, timeframe=“1m”, lookback=5), )

Role: INDICATOR | Ephemeral: No

Parameters

Parameter	Type	Default	Description
open_	'Input'	Required
high	'Input'	Required
low	'Input'	Required
close	'Input'	Required

Usage

pattern = CDLDOJISTAR(
    Input("FIELD:open", timeframe="1m", lookback=5),
    Input("FIELD:high", timeframe="1m", lookback=5),
    Input("FIELD:low", timeframe="1m", lookback=5),
    Input("FIELD:close", timeframe="1m", lookback=5),
)

Source Code

Full compute() implementation — no hidden logic.

def compute(self, data, timestamp=None, context=None) -> TaggedArray:
    if not isinstance(data, list) or len(data) < 4:
        return self._empty_output()

    n_time = len(data[0])
    if n_time < 2:
        return self._empty_output()

    o1, h1, l1, c1 = self._get_ohlc(data, -2)
    o2, h2, l2, c2 = self._get_ohlc(data, -1)

    n_symbols = len(o2)
    exists = data[3][-1].exists
    valid = data[3][-1].valid
    result = np.zeros(n_symbols)

    for i in range(n_symbols):
        if exists[i] and valid[i] and not any(np.isnan([o1[i], h1[i], l1[i], c1[i], o2[i], h2[i], l2[i], c2[i]])):
            body2 = self._body_size(o2[i], c2[i])
            range2 = h2[i] - l2[i]
            is_doji = range2 > 0 and body2 / range2 < 0.1

            if is_doji:
                if self._is_bullish(o1[i], c1[i]) and l2[i] > c1[i]:  # Gap up doji
                    result[i] = -100.0
                elif self._is_bearish(o1[i], c1[i]) and h2[i] < c1[i]:  # Gap down doji
                    result[i] = 100.0

    result_valid = exists & valid
    return TaggedArray(
        value=result,
        exists=exists,
        valid=result_valid,
        updated=np.ones(n_symbols, dtype=bool),
    )

_{Source: apps/trading/operators/indicator/patterns.py}

---

CDLDRAGONFLYDOJI

Dragonfly Doji - Bullish reversal doji with long lower shadow.

Example: pattern = CDLDRAGONFLYDOJI( Input(“FIELD:open”, timeframe=“1m”, lookback=5), Input(“FIELD:high”, timeframe=“1m”, lookback=5), Input(“FIELD:low”, timeframe=“1m”, lookback=5), Input(“FIELD:close”, timeframe=“1m”, lookback=5), )

Role: INDICATOR | Ephemeral: No

Parameters

Parameter	Type	Default	Description
open_	'Input'	Required
high	'Input'	Required
low	'Input'	Required
close	'Input'	Required

Usage

pattern = CDLDRAGONFLYDOJI(
    Input("FIELD:open", timeframe="1m", lookback=5),
    Input("FIELD:high", timeframe="1m", lookback=5),
    Input("FIELD:low", timeframe="1m", lookback=5),
    Input("FIELD:close", timeframe="1m", lookback=5),
)

Source Code

Full compute() implementation — no hidden logic.

def compute(self, data, timestamp=None, context=None) -> TaggedArray:
    if not isinstance(data, list) or len(data) < 4:
        return self._empty_output()

    n_time = len(data[0])
    if n_time == 0:
        return self._empty_output()

    o, h, l, c = self._get_ohlc(data)
    n_symbols = len(o)
    exists = data[3][-1].exists
    valid = data[3][-1].valid
    result = np.zeros(n_symbols)

    for i in range(n_symbols):
        if exists[i] and valid[i] and not any(np.isnan([o[i], h[i], l[i], c[i]])):
            body = self._body_size(o[i], c[i])
            range_size = h[i] - l[i]
            lower_shadow = min(o[i], c[i]) - l[i]
            upper_shadow = h[i] - max(o[i], c[i])

            if range_size > 0:
                is_doji = body / range_size < 0.1
                has_long_lower = lower_shadow > range_size * 0.6
                has_small_upper = upper_shadow < range_size * 0.1

                if is_doji and has_long_lower and has_small_upper:
                    result[i] = 100.0

    result_valid = exists & valid
    return TaggedArray(
        value=result,
        exists=exists,
        valid=result_valid,
        updated=np.ones(n_symbols, dtype=bool),
    )

_{Source: apps/trading/operators/indicator/patterns.py}

---

CDLEVENINGDOJISTAR

Evening Doji Star - Bearish reversal with doji.

Example: pattern = CDLEVENINGDOJISTAR( Input(“FIELD:open”, timeframe=“1m”, lookback=5), Input(“FIELD:high”, timeframe=“1m”, lookback=5), Input(“FIELD:low”, timeframe=“1m”, lookback=5), Input(“FIELD:close”, timeframe=“1m”, lookback=5), )

Role: INDICATOR | Ephemeral: No

Parameters

Parameter	Type	Default	Description
open_	'Input'	Required
high	'Input'	Required
low	'Input'	Required
close	'Input'	Required

Usage

pattern = CDLEVENINGDOJISTAR(
    Input("FIELD:open", timeframe="1m", lookback=5),
    Input("FIELD:high", timeframe="1m", lookback=5),
    Input("FIELD:low", timeframe="1m", lookback=5),
    Input("FIELD:close", timeframe="1m", lookback=5),
)

Source Code

Full compute() implementation — no hidden logic.

def compute(self, data, timestamp=None, context=None) -> TaggedArray:
    if not isinstance(data, list) or len(data) < 4:
        return self._empty_output()

    n_time = len(data[0])
    if n_time < 3:
        return self._empty_output()

    o1, h1, l1, c1 = self._get_ohlc(data, -3)
    o2, h2, l2, c2 = self._get_ohlc(data, -2)
    o3, h3, l3, c3 = self._get_ohlc(data, -1)

    n_symbols = len(o3)
    exists = data[3][-1].exists
    valid = data[3][-1].valid
    result = np.zeros(n_symbols)

    for i in range(n_symbols):
        if exists[i] and valid[i]:
            if any(np.isnan([o1[i], c1[i], o2[i], h2[i], l2[i], c2[i], o3[i], c3[i]])):
                continue
            body2 = self._body_size(o2[i], c2[i])
            range2 = h2[i] - l2[i]
            is_doji = range2 > 0 and body2 / range2 < 0.1

            if (self._is_bullish(o1[i], c1[i]) and is_doji and l2[i] > c1[i] and
                self._is_bearish(o3[i], c3[i]) and c3[i] < (o1[i] + c1[i]) / 2):
                result[i] = -100.0

    result_valid = exists & valid
    return TaggedArray(
        value=result,
        exists=exists,
        valid=result_valid,
        updated=np.ones(n_symbols, dtype=bool),
    )

_{Source: apps/trading/operators/indicator/patterns.py}

---

CDLGAPSIDESIDEWHITE

Up/Down-gap side-by-side white lines - Continuation.

Example: pattern = CDLGAPSIDESIDEWHITE( Input(“FIELD:open”, timeframe=“1m”, lookback=5), Input(“FIELD:high”, timeframe=“1m”, lookback=5), Input(“FIELD:low”, timeframe=“1m”, lookback=5), Input(“FIELD:close”, timeframe=“1m”, lookback=5), )

Role: INDICATOR | Ephemeral: No

Parameters

Parameter	Type	Default	Description
open_	'Input'	Required
high	'Input'	Required
low	'Input'	Required
close	'Input'	Required

Usage

pattern = CDLGAPSIDESIDEWHITE(
    Input("FIELD:open", timeframe="1m", lookback=5),
    Input("FIELD:high", timeframe="1m", lookback=5),
    Input("FIELD:low", timeframe="1m", lookback=5),
    Input("FIELD:close", timeframe="1m", lookback=5),
)

Source Code

Full compute() implementation — no hidden logic.

def compute(self, data, timestamp=None, context=None) -> TaggedArray:
    if not isinstance(data, list) or len(data) < 4:
        return self._empty_output()

    n_time = len(data[0])
    if n_time < 3:
        return self._empty_output()

    o1, h1, l1, c1 = self._get_ohlc(data, -3)
    o2, h2, l2, c2 = self._get_ohlc(data, -2)
    o3, h3, l3, c3 = self._get_ohlc(data, -1)

    n_symbols = len(o3)
    exists = data[3][-1].exists
    valid = data[3][-1].valid
    result = np.zeros(n_symbols)

    for i in range(n_symbols):
        if exists[i] and valid[i]:
            if any(np.isnan([o1[i], c1[i], o2[i], c2[i], o3[i], c3[i]])):
                continue
            # Two similar bullish candles after gap
            body2 = self._body_size(o2[i], c2[i])
            body3 = self._body_size(o3[i], c3[i])
            if body2 > 0 and abs(body2 - body3) / body2 < 0.2:
                if self._is_bullish(o2[i], c2[i]) and self._is_bullish(o3[i], c3[i]):
                    if l2[i] > h1[i]:  # Gap up
                        result[i] = 100.0
                    elif h2[i] < l1[i]:  # Gap down
                        result[i] = -100.0

    result_valid = exists & valid
    return TaggedArray(
        value=result,
        exists=exists,
        valid=result_valid,
        updated=np.ones(n_symbols, dtype=bool),
    )

_{Source: apps/trading/operators/indicator/patterns.py}

---

CDLGRAVESTONEDOJI

Gravestone Doji - Bearish reversal doji with long upper shadow.

Example: pattern = CDLGRAVESTONEDOJI( Input(“FIELD:open”, timeframe=“1m”, lookback=5), Input(“FIELD:high”, timeframe=“1m”, lookback=5), Input(“FIELD:low”, timeframe=“1m”, lookback=5), Input(“FIELD:close”, timeframe=“1m”, lookback=5), )

Role: INDICATOR | Ephemeral: No

Parameters

Parameter	Type	Default	Description
open_	'Input'	Required
high	'Input'	Required
low	'Input'	Required
close	'Input'	Required

Usage

pattern = CDLGRAVESTONEDOJI(
    Input("FIELD:open", timeframe="1m", lookback=5),
    Input("FIELD:high", timeframe="1m", lookback=5),
    Input("FIELD:low", timeframe="1m", lookback=5),
    Input("FIELD:close", timeframe="1m", lookback=5),
)

Source Code

Full compute() implementation — no hidden logic.

def compute(self, data, timestamp=None, context=None) -> TaggedArray:
    if not isinstance(data, list) or len(data) < 4:
        return self._empty_output()

    n_time = len(data[0])
    if n_time == 0:
        return self._empty_output()

    o, h, l, c = self._get_ohlc(data)
    n_symbols = len(o)
    exists = data[3][-1].exists
    valid = data[3][-1].valid
    result = np.zeros(n_symbols)

    for i in range(n_symbols):
        if exists[i] and valid[i] and not any(np.isnan([o[i], h[i], l[i], c[i]])):
            body = self._body_size(o[i], c[i])
            range_size = h[i] - l[i]
            upper_shadow = h[i] - max(o[i], c[i])
            lower_shadow = min(o[i], c[i]) - l[i]

            if range_size > 0:
                is_doji = body / range_size < 0.1
                has_long_upper = upper_shadow > range_size * 0.6
                has_small_lower = lower_shadow < range_size * 0.1

                if is_doji and has_long_upper and has_small_lower:
                    result[i] = -100.0

    result_valid = exists & valid
    return TaggedArray(
        value=result,
        exists=exists,
        valid=result_valid,
        updated=np.ones(n_symbols, dtype=bool),
    )

_{Source: apps/trading/operators/indicator/patterns.py}

---

CDLHARAMICROSS

Harami Cross - Harami with doji second candle.

Example: pattern = CDLHARAMICROSS( Input(“FIELD:open”, timeframe=“1m”, lookback=5), Input(“FIELD:high”, timeframe=“1m”, lookback=5), Input(“FIELD:low”, timeframe=“1m”, lookback=5), Input(“FIELD:close”, timeframe=“1m”, lookback=5), )

Role: INDICATOR | Ephemeral: No

Parameters

Parameter	Type	Default	Description
open_	'Input'	Required
high	'Input'	Required
low	'Input'	Required
close	'Input'	Required

Usage

pattern = CDLHARAMICROSS(
    Input("FIELD:open", timeframe="1m", lookback=5),
    Input("FIELD:high", timeframe="1m", lookback=5),
    Input("FIELD:low", timeframe="1m", lookback=5),
    Input("FIELD:close", timeframe="1m", lookback=5),
)

Source Code

Full compute() implementation — no hidden logic.

def compute(self, data, timestamp=None, context=None) -> TaggedArray:
    if not isinstance(data, list) or len(data) < 4:
        return self._empty_output()

    n_time = len(data[0])
    if n_time < 2:
        return self._empty_output()

    o1, h1, l1, c1 = self._get_ohlc(data, -2)
    o2, h2, l2, c2 = self._get_ohlc(data, -1)

    n_symbols = len(o2)
    exists = data[3][-1].exists
    valid = data[3][-1].valid
    result = np.zeros(n_symbols)

    for i in range(n_symbols):
        if exists[i] and valid[i] and not any(np.isnan([o1[i], h1[i], l1[i], c1[i], o2[i], h2[i], l2[i], c2[i]])):
            body2 = self._body_size(o2[i], c2[i])
            range2 = h2[i] - l2[i]
            is_doji = range2 > 0 and body2 / range2 < 0.1

            if is_doji:
                min1, max1 = min(o1[i], c1[i]), max(o1[i], c1[i])
                if o2[i] > min1 and o2[i] < max1 and c2[i] > min1 and c2[i] < max1:
                    if self._is_bearish(o1[i], c1[i]):
                        result[i] = 100.0
                    else:
                        result[i] = -100.0

    result_valid = exists & valid
    return TaggedArray(
        value=result,
        exists=exists,
        valid=result_valid,
        updated=np.ones(n_symbols, dtype=bool),
    )

_{Source: apps/trading/operators/indicator/patterns.py}

---

CDLHIGHWAVE

High-Wave Candle - Indecision with long shadows.

Example: pattern = CDLHIGHWAVE( Input(“FIELD:open”, timeframe=“1m”, lookback=5), Input(“FIELD:high”, timeframe=“1m”, lookback=5), Input(“FIELD:low”, timeframe=“1m”, lookback=5), Input(“FIELD:close”, timeframe=“1m”, lookback=5), )

Role: INDICATOR | Ephemeral: No

Parameters

Parameter	Type	Default	Description
open_	'Input'	Required
high	'Input'	Required
low	'Input'	Required
close	'Input'	Required

Usage

pattern = CDLHIGHWAVE(
    Input("FIELD:open", timeframe="1m", lookback=5),
    Input("FIELD:high", timeframe="1m", lookback=5),
    Input("FIELD:low", timeframe="1m", lookback=5),
    Input("FIELD:close", timeframe="1m", lookback=5),
)

Source Code

Full compute() implementation — no hidden logic.

def compute(self, data, timestamp=None, context=None) -> TaggedArray:
    if not isinstance(data, list) or len(data) < 4:
        return self._empty_output()

    n_time = len(data[0])
    if n_time == 0:
        return self._empty_output()

    o, h, l, c = self._get_ohlc(data)
    n_symbols = len(o)
    exists = data[3][-1].exists
    valid = data[3][-1].valid
    result = np.zeros(n_symbols)

    for i in range(n_symbols):
        if exists[i] and valid[i] and not any(np.isnan([o[i], h[i], l[i], c[i]])):
            body = self._body_size(o[i], c[i])
            range_size = h[i] - l[i]
            upper_shadow = h[i] - max(o[i], c[i])
            lower_shadow = min(o[i], c[i]) - l[i]

            if range_size > 0 and body > 0:
                # Small body with long shadows on both sides
                if (body / range_size < 0.3 and
                    upper_shadow > body and lower_shadow > body):
                    result[i] = 100.0  # Indecision signal

    result_valid = exists & valid
    return TaggedArray(
        value=result,
        exists=exists,
        valid=result_valid,
        updated=np.ones(n_symbols, dtype=bool),
    )

_{Source: apps/trading/operators/indicator/patterns.py}

---

CDLHIKKAKE

Hikkake Pattern - Inside bar breakout failure.

Example: pattern = CDLHIKKAKE( Input(“FIELD:open”, timeframe=“1m”, lookback=5), Input(“FIELD:high”, timeframe=“1m”, lookback=5), Input(“FIELD:low”, timeframe=“1m”, lookback=5), Input(“FIELD:close”, timeframe=“1m”, lookback=5), )

Role: INDICATOR | Ephemeral: No

Parameters

Parameter	Type	Default	Description
open_	'Input'	Required
high	'Input'	Required
low	'Input'	Required
close	'Input'	Required

Usage

pattern = CDLHIKKAKE(
    Input("FIELD:open", timeframe="1m", lookback=5),
    Input("FIELD:high", timeframe="1m", lookback=5),
    Input("FIELD:low", timeframe="1m", lookback=5),
    Input("FIELD:close", timeframe="1m", lookback=5),
)

Source Code

Full compute() implementation — no hidden logic.

def compute(self, data, timestamp=None, context=None) -> TaggedArray:
    if not isinstance(data, list) or len(data) < 4:
        return self._empty_output()

    n_time = len(data[0])
    if n_time < 4:
        return self._empty_output()

    n_symbols = len(data[0][-1].value)
    exists = data[3][-1].exists
    valid = data[3][-1].valid
    result = np.zeros(n_symbols)

    ohlc = [self._get_ohlc(data, -4+j) for j in range(4)]

    for i in range(n_symbols):
        if exists[i] and valid[i]:
            h = [ohlc[j][1][i] for j in range(4)]
            l = [ohlc[j][2][i] for j in range(4)]
            c = [ohlc[j][3][i] for j in range(4)]
            if any(np.isnan(h + l + c)):
                continue
            # Inside bar then breakout failure
            if h[1] < h[0] and l[1] > l[0]:  # Inside bar
                if c[3] > h[0]:  # Bullish breakout
                    result[i] = 100.0
                elif c[3] < l[0]:  # Bearish breakout
                    result[i] = -100.0

    result_valid = exists & valid
    return TaggedArray(
        value=result,
        exists=exists,
        valid=result_valid,
        updated=np.ones(n_symbols, dtype=bool),
    )

_{Source: apps/trading/operators/indicator/patterns.py}

---

CDLHIKKAKEMOD

Modified Hikkake Pattern.

Example: pattern = CDLHIKKAKEMOD( Input(“FIELD:open”, timeframe=“1m”, lookback=5), Input(“FIELD:high”, timeframe=“1m”, lookback=5), Input(“FIELD:low”, timeframe=“1m”, lookback=5), Input(“FIELD:close”, timeframe=“1m”, lookback=5), )

Role: INDICATOR | Ephemeral: No

Parameters

Parameter	Type	Default	Description
open_	'Input'	Required
high	'Input'	Required
low	'Input'	Required
close	'Input'	Required

Usage

pattern = CDLHIKKAKEMOD(
    Input("FIELD:open", timeframe="1m", lookback=5),
    Input("FIELD:high", timeframe="1m", lookback=5),
    Input("FIELD:low", timeframe="1m", lookback=5),
    Input("FIELD:close", timeframe="1m", lookback=5),
)

Source Code

Full compute() implementation — no hidden logic.

def compute(self, data, timestamp=None, context=None) -> TaggedArray:
    if not isinstance(data, list) or len(data) < 4:
        return self._empty_output()

    n_time = len(data[0])
    if n_time < 5:
        return self._empty_output()

    n_symbols = len(data[0][-1].value)
    exists = data[3][-1].exists
    valid = data[3][-1].valid
    result = np.zeros(n_symbols)

    ohlc = [self._get_ohlc(data, -5+j) for j in range(5)]

    for i in range(n_symbols):
        if exists[i] and valid[i]:
            h = [ohlc[j][1][i] for j in range(5)]
            l = [ohlc[j][2][i] for j in range(5)]
            c = [ohlc[j][3][i] for j in range(5)]
            if any(np.isnan(h + l + c)):
                continue
            # Modified version with confirmation
            if h[1] < h[0] and l[1] > l[0] and h[2] < h[1] and l[2] > l[1]:
                if c[4] > h[0]:
                    result[i] = 100.0
                elif c[4] < l[0]:
                    result[i] = -100.0

    result_valid = exists & valid
    return TaggedArray(
        value=result,
        exists=exists,
        valid=result_valid,
        updated=np.ones(n_symbols, dtype=bool),
    )

_{Source: apps/trading/operators/indicator/patterns.py}

---

CDLHOMINGPIGEON

Homing Pigeon - Bullish harami-like pattern.

Example: pattern = CDLHOMINGPIGEON( Input(“FIELD:open”, timeframe=“1m”, lookback=5), Input(“FIELD:high”, timeframe=“1m”, lookback=5), Input(“FIELD:low”, timeframe=“1m”, lookback=5), Input(“FIELD:close”, timeframe=“1m”, lookback=5), )

Role: INDICATOR | Ephemeral: No

Parameters

Parameter	Type	Default	Description
open_	'Input'	Required
high	'Input'	Required
low	'Input'	Required
close	'Input'	Required

Usage

pattern = CDLHOMINGPIGEON(
    Input("FIELD:open", timeframe="1m", lookback=5),
    Input("FIELD:high", timeframe="1m", lookback=5),
    Input("FIELD:low", timeframe="1m", lookback=5),
    Input("FIELD:close", timeframe="1m", lookback=5),
)

Source Code

Full compute() implementation — no hidden logic.

def compute(self, data, timestamp=None, context=None) -> TaggedArray:
    if not isinstance(data, list) or len(data) < 4:
        return self._empty_output()

    n_time = len(data[0])
    if n_time < 2:
        return self._empty_output()

    o1, h1, l1, c1 = self._get_ohlc(data, -2)
    o2, h2, l2, c2 = self._get_ohlc(data, -1)

    n_symbols = len(o2)
    exists = data[3][-1].exists
    valid = data[3][-1].valid
    result = np.zeros(n_symbols)

    for i in range(n_symbols):
        if exists[i] and valid[i] and not any(np.isnan([o1[i], c1[i], o2[i], c2[i]])):
            # Two bearish candles, second inside first
            if (self._is_bearish(o1[i], c1[i]) and self._is_bearish(o2[i], c2[i]) and
                o2[i] < o1[i] and c2[i] > c1[i]):
                result[i] = 100.0

    result_valid = exists & valid
    return TaggedArray(
        value=result,
        exists=exists,
        valid=result_valid,
        updated=np.ones(n_symbols, dtype=bool),
    )

_{Source: apps/trading/operators/indicator/patterns.py}

---

CDLIDENTICAL3CROWS

Identical Three Crows - Strong bearish continuation.

Example: pattern = CDLIDENTICAL3CROWS( Input(“FIELD:open”, timeframe=“1m”, lookback=5), Input(“FIELD:high”, timeframe=“1m”, lookback=5), Input(“FIELD:low”, timeframe=“1m”, lookback=5), Input(“FIELD:close”, timeframe=“1m”, lookback=5), )

Role: INDICATOR | Ephemeral: No

Parameters

Parameter	Type	Default	Description
open_	'Input'	Required
high	'Input'	Required
low	'Input'	Required
close	'Input'	Required

Usage

pattern = CDLIDENTICAL3CROWS(
    Input("FIELD:open", timeframe="1m", lookback=5),
    Input("FIELD:high", timeframe="1m", lookback=5),
    Input("FIELD:low", timeframe="1m", lookback=5),
    Input("FIELD:close", timeframe="1m", lookback=5),
)

Source Code

Full compute() implementation — no hidden logic.

def compute(self, data, timestamp=None, context=None) -> TaggedArray:
    if not isinstance(data, list) or len(data) < 4:
        return self._empty_output()

    n_time = len(data[0])
    if n_time < 3:
        return self._empty_output()

    o1, h1, l1, c1 = self._get_ohlc(data, -3)
    o2, h2, l2, c2 = self._get_ohlc(data, -2)
    o3, h3, l3, c3 = self._get_ohlc(data, -1)

    n_symbols = len(o3)
    exists = data[3][-1].exists
    valid = data[3][-1].valid
    result = np.zeros(n_symbols)

    for i in range(n_symbols):
        if exists[i] and valid[i]:
            if any(np.isnan([o1[i], c1[i], o2[i], c2[i], o3[i], c3[i]])):
                continue
            # Three bearish, each opens at or near previous close
            if (self._is_bearish(o1[i], c1[i]) and self._is_bearish(o2[i], c2[i]) and
                self._is_bearish(o3[i], c3[i]) and
                abs(o2[i] - c1[i]) < self._body_size(o1[i], c1[i]) * 0.1 and
                abs(o3[i] - c2[i]) < self._body_size(o2[i], c2[i]) * 0.1):
                result[i] = -100.0

    result_valid = exists & valid
    return TaggedArray(
        value=result,
        exists=exists,
        valid=result_valid,
        updated=np.ones(n_symbols, dtype=bool),
    )

_{Source: apps/trading/operators/indicator/patterns.py}

---

CDLINNECK

In-Neck Pattern - Bearish continuation.

Example: pattern = CDLINNECK( Input(“FIELD:open”, timeframe=“1m”, lookback=5), Input(“FIELD:high”, timeframe=“1m”, lookback=5), Input(“FIELD:low”, timeframe=“1m”, lookback=5), Input(“FIELD:close”, timeframe=“1m”, lookback=5), )

Role: INDICATOR | Ephemeral: No

Parameters

Parameter	Type	Default	Description
open_	'Input'	Required
high	'Input'	Required
low	'Input'	Required
close	'Input'	Required

Usage

pattern = CDLINNECK(
    Input("FIELD:open", timeframe="1m", lookback=5),
    Input("FIELD:high", timeframe="1m", lookback=5),
    Input("FIELD:low", timeframe="1m", lookback=5),
    Input("FIELD:close", timeframe="1m", lookback=5),
)

Source Code

Full compute() implementation — no hidden logic.

def compute(self, data, timestamp=None, context=None) -> TaggedArray:
    if not isinstance(data, list) or len(data) < 4:
        return self._empty_output()

    n_time = len(data[0])
    if n_time < 2:
        return self._empty_output()

    o1, h1, l1, c1 = self._get_ohlc(data, -2)
    o2, h2, l2, c2 = self._get_ohlc(data, -1)

    n_symbols = len(o2)
    exists = data[3][-1].exists
    valid = data[3][-1].valid
    result = np.zeros(n_symbols)

    for i in range(n_symbols):
        if exists[i] and valid[i] and not any(np.isnan([o1[i], c1[i], o2[i], c2[i]])):
            # Bearish first, bullish second closing at or slightly above first's close
            if (self._is_bearish(o1[i], c1[i]) and self._is_bullish(o2[i], c2[i]) and
                o2[i] < c1[i] and abs(c2[i] - c1[i]) < self._body_size(o1[i], c1[i]) * 0.1):
                result[i] = -100.0

    result_valid = exists & valid
    return TaggedArray(
        value=result,
        exists=exists,
        valid=result_valid,
        updated=np.ones(n_symbols, dtype=bool),
    )

_{Source: apps/trading/operators/indicator/patterns.py}

---

CDLKICKING

Kicking - Strong reversal with marubozu gap.

Example: pattern = CDLKICKING( Input(“FIELD:open”, timeframe=“1m”, lookback=5), Input(“FIELD:high”, timeframe=“1m”, lookback=5), Input(“FIELD:low”, timeframe=“1m”, lookback=5), Input(“FIELD:close”, timeframe=“1m”, lookback=5), )

Role: INDICATOR | Ephemeral: No

Parameters

Parameter	Type	Default	Description
open_	'Input'	Required
high	'Input'	Required
low	'Input'	Required
close	'Input'	Required

Usage

pattern = CDLKICKING(
    Input("FIELD:open", timeframe="1m", lookback=5),
    Input("FIELD:high", timeframe="1m", lookback=5),
    Input("FIELD:low", timeframe="1m", lookback=5),
    Input("FIELD:close", timeframe="1m", lookback=5),
)

Source Code

Full compute() implementation — no hidden logic.

def compute(self, data, timestamp=None, context=None) -> TaggedArray:
    if not isinstance(data, list) or len(data) < 4:
        return self._empty_output()

    n_time = len(data[0])
    if n_time < 2:
        return self._empty_output()

    o1, h1, l1, c1 = self._get_ohlc(data, -2)
    o2, h2, l2, c2 = self._get_ohlc(data, -1)

    n_symbols = len(o2)
    exists = data[3][-1].exists
    valid = data[3][-1].valid
    result = np.zeros(n_symbols)

    for i in range(n_symbols):
        if exists[i] and valid[i] and not any(np.isnan([o1[i], h1[i], l1[i], c1[i], o2[i], h2[i], l2[i], c2[i]])):
            body1 = self._body_size(o1[i], c1[i])
            body2 = self._body_size(o2[i], c2[i])
            range1 = h1[i] - l1[i]
            range2 = h2[i] - l2[i]

            # Both should be marubozu-like
            is_maru1 = range1 > 0 and body1 / range1 > 0.9
            is_maru2 = range2 > 0 and body2 / range2 > 0.9

            if is_maru1 and is_maru2:
                # Bullish kicking: bearish marubozu gap up to bullish marubozu
                if self._is_bearish(o1[i], c1[i]) and self._is_bullish(o2[i], c2[i]) and l2[i] > h1[i]:
                    result[i] = 100.0
                # Bearish kicking: bullish marubozu gap down to bearish marubozu
                elif self._is_bullish(o1[i], c1[i]) and self._is_bearish(o2[i], c2[i]) and h2[i] < l1[i]:
                    result[i] = -100.0

    result_valid = exists & valid
    return TaggedArray(
        value=result,
        exists=exists,
        valid=result_valid,
        updated=np.ones(n_symbols, dtype=bool),
    )

_{Source: apps/trading/operators/indicator/patterns.py}

---

CDLKICKINGBYLENGTH

Kicking - bull/bear determined by the longer marubozu.

Example: pattern = CDLKICKINGBYLENGTH( Input(“FIELD:open”, timeframe=“1m”, lookback=5), Input(“FIELD:high”, timeframe=“1m”, lookback=5), Input(“FIELD:low”, timeframe=“1m”, lookback=5), Input(“FIELD:close”, timeframe=“1m”, lookback=5), )

Role: INDICATOR | Ephemeral: No

Parameters

Parameter	Type	Default	Description
open_	'Input'	Required
high	'Input'	Required
low	'Input'	Required
close	'Input'	Required

Usage

pattern = CDLKICKINGBYLENGTH(
    Input("FIELD:open", timeframe="1m", lookback=5),
    Input("FIELD:high", timeframe="1m", lookback=5),
    Input("FIELD:low", timeframe="1m", lookback=5),
    Input("FIELD:close", timeframe="1m", lookback=5),
)

Source Code

Full compute() implementation — no hidden logic.

def compute(self, data, timestamp=None, context=None) -> TaggedArray:
    if not isinstance(data, list) or len(data) < 4:
        return self._empty_output()

    n_time = len(data[0])
    if n_time < 2:
        return self._empty_output()

    o1, h1, l1, c1 = self._get_ohlc(data, -2)
    o2, h2, l2, c2 = self._get_ohlc(data, -1)

    n_symbols = len(o2)
    exists = data[3][-1].exists
    valid = data[3][-1].valid
    result = np.zeros(n_symbols)

    for i in range(n_symbols):
        if exists[i] and valid[i] and not any(np.isnan([o1[i], h1[i], l1[i], c1[i], o2[i], h2[i], l2[i], c2[i]])):
            body1 = self._body_size(o1[i], c1[i])
            body2 = self._body_size(o2[i], c2[i])
            range1 = h1[i] - l1[i]
            range2 = h2[i] - l2[i]

            is_maru1 = range1 > 0 and body1 / range1 > 0.9
            is_maru2 = range2 > 0 and body2 / range2 > 0.9

            if is_maru1 and is_maru2:
                # Determine by longer body
                if body2 > body1:
                    if self._is_bullish(o2[i], c2[i]):
                        result[i] = 100.0
                    else:
                        result[i] = -100.0
                else:
                    if self._is_bullish(o1[i], c1[i]):
                        result[i] = -100.0  # Reversal expected
                    else:
                        result[i] = 100.0

    result_valid = exists & valid
    return TaggedArray(
        value=result,
        exists=exists,
        valid=result_valid,
        updated=np.ones(n_symbols, dtype=bool),
    )

_{Source: apps/trading/operators/indicator/patterns.py}

---

CDLLADDERBOTTOM

Ladder Bottom - Bullish reversal.

Example: pattern = CDLLADDERBOTTOM( Input(“FIELD:open”, timeframe=“1m”, lookback=5), Input(“FIELD:high”, timeframe=“1m”, lookback=5), Input(“FIELD:low”, timeframe=“1m”, lookback=5), Input(“FIELD:close”, timeframe=“1m”, lookback=5), )

Role: INDICATOR | Ephemeral: No

Parameters

Parameter	Type	Default	Description
open_	'Input'	Required
high	'Input'	Required
low	'Input'	Required
close	'Input'	Required

Usage

pattern = CDLLADDERBOTTOM(
    Input("FIELD:open", timeframe="1m", lookback=5),
    Input("FIELD:high", timeframe="1m", lookback=5),
    Input("FIELD:low", timeframe="1m", lookback=5),
    Input("FIELD:close", timeframe="1m", lookback=5),
)

Source Code

Full compute() implementation — no hidden logic.

def compute(self, data, timestamp=None, context=None) -> TaggedArray:
    if not isinstance(data, list) or len(data) < 4:
        return self._empty_output()

    n_time = len(data[0])
    if n_time < 5:
        return self._empty_output()

    n_symbols = len(data[0][-1].value)
    exists = data[3][-1].exists
    valid = data[3][-1].valid
    result = np.zeros(n_symbols)

    ohlc = [self._get_ohlc(data, -5+j) for j in range(5)]

    for i in range(n_symbols):
        if exists[i] and valid[i]:
            o = [ohlc[j][0][i] for j in range(5)]
            c = [ohlc[j][3][i] for j in range(5)]
            if any(np.isnan(o + c)):
                continue
            # Three bearish with lower closes, then bullish reversal
            if (self._is_bearish(o[0], c[0]) and self._is_bearish(o[1], c[1]) and
                self._is_bearish(o[2], c[2]) and c[1] < c[0] and c[2] < c[1] and
                self._is_bullish(o[4], c[4]) and c[4] > o[2]):
                result[i] = 100.0

    result_valid = exists & valid
    return TaggedArray(
        value=result,
        exists=exists,
        valid=result_valid,
        updated=np.ones(n_symbols, dtype=bool),
    )

_{Source: apps/trading/operators/indicator/patterns.py}

---

CDLLONGLEGGEDDOJI

Long Legged Doji - Doji with long shadows both sides.

Example: pattern = CDLLONGLEGGEDDOJI( Input(“FIELD:open”, timeframe=“1m”, lookback=5), Input(“FIELD:high”, timeframe=“1m”, lookback=5), Input(“FIELD:low”, timeframe=“1m”, lookback=5), Input(“FIELD:close”, timeframe=“1m”, lookback=5), )

Role: INDICATOR | Ephemeral: No

Parameters

Parameter	Type	Default	Description
open_	'Input'	Required
high	'Input'	Required
low	'Input'	Required
close	'Input'	Required

Usage

pattern = CDLLONGLEGGEDDOJI(
    Input("FIELD:open", timeframe="1m", lookback=5),
    Input("FIELD:high", timeframe="1m", lookback=5),
    Input("FIELD:low", timeframe="1m", lookback=5),
    Input("FIELD:close", timeframe="1m", lookback=5),
)

Source Code

Full compute() implementation — no hidden logic.

def compute(self, data, timestamp=None, context=None) -> TaggedArray:
    if not isinstance(data, list) or len(data) < 4:
        return self._empty_output()

    n_time = len(data[0])
    if n_time == 0:
        return self._empty_output()

    o, h, l, c = self._get_ohlc(data)
    n_symbols = len(o)
    exists = data[3][-1].exists
    valid = data[3][-1].valid
    result = np.zeros(n_symbols)

    for i in range(n_symbols):
        if exists[i] and valid[i] and not any(np.isnan([o[i], h[i], l[i], c[i]])):
            body = self._body_size(o[i], c[i])
            range_size = h[i] - l[i]
            upper_shadow = h[i] - max(o[i], c[i])
            lower_shadow = min(o[i], c[i]) - l[i]

            if range_size > 0:
                is_doji = body / range_size < 0.1
                has_long_shadows = upper_shadow > range_size * 0.3 and lower_shadow > range_size * 0.3

                if is_doji and has_long_shadows:
                    result[i] = 100.0

    result_valid = exists & valid
    return TaggedArray(
        value=result,
        exists=exists,
        valid=result_valid,
        updated=np.ones(n_symbols, dtype=bool),
    )

_{Source: apps/trading/operators/indicator/patterns.py}

---

CDLLONGLINE

Long Line Candle - Strong directional candle.

Example: pattern = CDLLONGLINE( Input(“FIELD:open”, timeframe=“1m”, lookback=5), Input(“FIELD:high”, timeframe=“1m”, lookback=5), Input(“FIELD:low”, timeframe=“1m”, lookback=5), Input(“FIELD:close”, timeframe=“1m”, lookback=5), )

Role: INDICATOR | Ephemeral: No

Parameters

Parameter	Type	Default	Description
open_	'Input'	Required
high	'Input'	Required
low	'Input'	Required
close	'Input'	Required

Usage

pattern = CDLLONGLINE(
    Input("FIELD:open", timeframe="1m", lookback=5),
    Input("FIELD:high", timeframe="1m", lookback=5),
    Input("FIELD:low", timeframe="1m", lookback=5),
    Input("FIELD:close", timeframe="1m", lookback=5),
)

Source Code

Full compute() implementation — no hidden logic.

def compute(self, data, timestamp=None, context=None) -> TaggedArray:
    if not isinstance(data, list) or len(data) < 4:
        return self._empty_output()

    n_time = len(data[0])
    if n_time == 0:
        return self._empty_output()

    o, h, l, c = self._get_ohlc(data)
    n_symbols = len(o)
    exists = data[3][-1].exists
    valid = data[3][-1].valid
    result = np.zeros(n_symbols)

    for i in range(n_symbols):
        if exists[i] and valid[i] and not any(np.isnan([o[i], h[i], l[i], c[i]])):
            body = self._body_size(o[i], c[i])
            range_size = h[i] - l[i]

            if range_size > 0 and body / range_size > 0.7:
                if self._is_bullish(o[i], c[i]):
                    result[i] = 100.0
                else:
                    result[i] = -100.0

    result_valid = exists & valid
    return TaggedArray(
        value=result,
        exists=exists,
        valid=result_valid,
        updated=np.ones(n_symbols, dtype=bool),
    )

_{Source: apps/trading/operators/indicator/patterns.py}

---

CDLMATCHINGLOW

Matching Low - Bullish reversal with equal lows.

Example: pattern = CDLMATCHINGLOW( Input(“FIELD:open”, timeframe=“1m”, lookback=5), Input(“FIELD:high”, timeframe=“1m”, lookback=5), Input(“FIELD:low”, timeframe=“1m”, lookback=5), Input(“FIELD:close”, timeframe=“1m”, lookback=5), )

Role: INDICATOR | Ephemeral: No

Parameters

Parameter	Type	Default	Description
open_	'Input'	Required
high	'Input'	Required
low	'Input'	Required
close	'Input'	Required

Usage

pattern = CDLMATCHINGLOW(
    Input("FIELD:open", timeframe="1m", lookback=5),
    Input("FIELD:high", timeframe="1m", lookback=5),
    Input("FIELD:low", timeframe="1m", lookback=5),
    Input("FIELD:close", timeframe="1m", lookback=5),
)

Source Code

Full compute() implementation — no hidden logic.

def compute(self, data, timestamp=None, context=None) -> TaggedArray:
    if not isinstance(data, list) or len(data) < 4:
        return self._empty_output()

    n_time = len(data[0])
    if n_time < 2:
        return self._empty_output()

    o1, h1, l1, c1 = self._get_ohlc(data, -2)
    o2, h2, l2, c2 = self._get_ohlc(data, -1)

    n_symbols = len(o2)
    exists = data[3][-1].exists
    valid = data[3][-1].valid
    result = np.zeros(n_symbols)

    for i in range(n_symbols):
        if exists[i] and valid[i] and not any(np.isnan([o1[i], c1[i], o2[i], c2[i]])):
            # Two bearish with matching closes
            if (self._is_bearish(o1[i], c1[i]) and self._is_bearish(o2[i], c2[i]) and
                abs(c1[i] - c2[i]) < self._body_size(o1[i], c1[i]) * 0.05):
                result[i] = 100.0

    result_valid = exists & valid
    return TaggedArray(
        value=result,
        exists=exists,
        valid=result_valid,
        updated=np.ones(n_symbols, dtype=bool),
    )

_{Source: apps/trading/operators/indicator/patterns.py}

---

CDLMATHOLD

Mat Hold - Bullish continuation.

Example: pattern = CDLMATHOLD( Input(“FIELD:open”, timeframe=“1m”, lookback=5), Input(“FIELD:high”, timeframe=“1m”, lookback=5), Input(“FIELD:low”, timeframe=“1m”, lookback=5), Input(“FIELD:close”, timeframe=“1m”, lookback=5), )

Role: INDICATOR | Ephemeral: No

Parameters

Parameter	Type	Default	Description
open_	'Input'	Required
high	'Input'	Required
low	'Input'	Required
close	'Input'	Required

Usage

pattern = CDLMATHOLD(
    Input("FIELD:open", timeframe="1m", lookback=5),
    Input("FIELD:high", timeframe="1m", lookback=5),
    Input("FIELD:low", timeframe="1m", lookback=5),
    Input("FIELD:close", timeframe="1m", lookback=5),
)

Source Code

Full compute() implementation — no hidden logic.

def compute(self, data, timestamp=None, context=None) -> TaggedArray:
    if not isinstance(data, list) or len(data) < 4:
        return self._empty_output()

    n_time = len(data[0])
    if n_time < 5:
        return self._empty_output()

    n_symbols = len(data[0][-1].value)
    exists = data[3][-1].exists
    valid = data[3][-1].valid
    result = np.zeros(n_symbols)

    ohlc = [self._get_ohlc(data, -5+j) for j in range(5)]

    for i in range(n_symbols):
        if exists[i] and valid[i]:
            o = [ohlc[j][0][i] for j in range(5)]
            c = [ohlc[j][3][i] for j in range(5)]
            if any(np.isnan(o + c)):
                continue
            # Long bullish, three small bearish, long bullish continuation
            if (self._is_bullish(o[0], c[0]) and
                self._is_bearish(o[1], c[1]) and self._is_bearish(o[2], c[2]) and
                self._is_bullish(o[4], c[4]) and c[4] > c[0]):
                result[i] = 100.0

    result_valid = exists & valid
    return TaggedArray(
        value=result,
        exists=exists,
        valid=result_valid,
        updated=np.ones(n_symbols, dtype=bool),
    )

_{Source: apps/trading/operators/indicator/patterns.py}

---

CDLMORNINGDOJISTAR

Morning Doji Star - Bullish reversal with doji.

Example: pattern = CDLMORNINGDOJISTAR( Input(“FIELD:open”, timeframe=“1m”, lookback=5), Input(“FIELD:high”, timeframe=“1m”, lookback=5), Input(“FIELD:low”, timeframe=“1m”, lookback=5), Input(“FIELD:close”, timeframe=“1m”, lookback=5), )

Role: INDICATOR | Ephemeral: No

Parameters

Parameter	Type	Default	Description
open_	'Input'	Required
high	'Input'	Required
low	'Input'	Required
close	'Input'	Required

Usage

pattern = CDLMORNINGDOJISTAR(
    Input("FIELD:open", timeframe="1m", lookback=5),
    Input("FIELD:high", timeframe="1m", lookback=5),
    Input("FIELD:low", timeframe="1m", lookback=5),
    Input("FIELD:close", timeframe="1m", lookback=5),
)

Source Code

Full compute() implementation — no hidden logic.

def compute(self, data, timestamp=None, context=None) -> TaggedArray:
    if not isinstance(data, list) or len(data) < 4:
        return self._empty_output()

    n_time = len(data[0])
    if n_time < 3:
        return self._empty_output()

    o1, h1, l1, c1 = self._get_ohlc(data, -3)
    o2, h2, l2, c2 = self._get_ohlc(data, -2)
    o3, h3, l3, c3 = self._get_ohlc(data, -1)

    n_symbols = len(o3)
    exists = data[3][-1].exists
    valid = data[3][-1].valid
    result = np.zeros(n_symbols)

    for i in range(n_symbols):
        if exists[i] and valid[i]:
            if any(np.isnan([o1[i], c1[i], o2[i], h2[i], l2[i], c2[i], o3[i], c3[i]])):
                continue
            body2 = self._body_size(o2[i], c2[i])
            range2 = h2[i] - l2[i]
            is_doji = range2 > 0 and body2 / range2 < 0.1

            if (self._is_bearish(o1[i], c1[i]) and is_doji and h2[i] < c1[i] and
                self._is_bullish(o3[i], c3[i]) and c3[i] > (o1[i] + c1[i]) / 2):
                result[i] = 100.0

    result_valid = exists & valid
    return TaggedArray(
        value=result,
        exists=exists,
        valid=result_valid,
        updated=np.ones(n_symbols, dtype=bool),
    )

_{Source: apps/trading/operators/indicator/patterns.py}

---

CDLONNECK

On-Neck Pattern - Bearish continuation.

Example: pattern = CDLONNECK( Input(“FIELD:open”, timeframe=“1m”, lookback=5), Input(“FIELD:high”, timeframe=“1m”, lookback=5), Input(“FIELD:low”, timeframe=“1m”, lookback=5), Input(“FIELD:close”, timeframe=“1m”, lookback=5), )

Role: INDICATOR | Ephemeral: No

Parameters

Parameter	Type	Default	Description
open_	'Input'	Required
high	'Input'	Required
low	'Input'	Required
close	'Input'	Required

Usage

pattern = CDLONNECK(
    Input("FIELD:open", timeframe="1m", lookback=5),
    Input("FIELD:high", timeframe="1m", lookback=5),
    Input("FIELD:low", timeframe="1m", lookback=5),
    Input("FIELD:close", timeframe="1m", lookback=5),
)

Source Code

Full compute() implementation — no hidden logic.

def compute(self, data, timestamp=None, context=None) -> TaggedArray:
    if not isinstance(data, list) or len(data) < 4:
        return self._empty_output()

    n_time = len(data[0])
    if n_time < 2:
        return self._empty_output()

    o1, h1, l1, c1 = self._get_ohlc(data, -2)
    o2, h2, l2, c2 = self._get_ohlc(data, -1)

    n_symbols = len(o2)
    exists = data[3][-1].exists
    valid = data[3][-1].valid
    result = np.zeros(n_symbols)

    for i in range(n_symbols):
        if exists[i] and valid[i] and not any(np.isnan([o1[i], l1[i], c1[i], o2[i], c2[i]])):
            # Bearish first, bullish second closing at first's low
            if (self._is_bearish(o1[i], c1[i]) and self._is_bullish(o2[i], c2[i]) and
                o2[i] < c1[i] and abs(c2[i] - l1[i]) < self._body_size(o1[i], c1[i]) * 0.1):
                result[i] = -100.0

    result_valid = exists & valid
    return TaggedArray(
        value=result,
        exists=exists,
        valid=result_valid,
        updated=np.ones(n_symbols, dtype=bool),
    )

_{Source: apps/trading/operators/indicator/patterns.py}

---

CDLPIERCING

Piercing Pattern - Bullish reversal.

Example: pattern = CDLPIERCING( Input(“FIELD:open”, timeframe=“1m”, lookback=5), Input(“FIELD:high”, timeframe=“1m”, lookback=5), Input(“FIELD:low”, timeframe=“1m”, lookback=5), Input(“FIELD:close”, timeframe=“1m”, lookback=5), )

Role: INDICATOR | Ephemeral: No

Parameters

Parameter	Type	Default	Description
open_	'Input'	Required
high	'Input'	Required
low	'Input'	Required
close	'Input'	Required

Usage

pattern = CDLPIERCING(
    Input("FIELD:open", timeframe="1m", lookback=5),
    Input("FIELD:high", timeframe="1m", lookback=5),
    Input("FIELD:low", timeframe="1m", lookback=5),
    Input("FIELD:close", timeframe="1m", lookback=5),
)

Source Code

Full compute() implementation — no hidden logic.

def compute(self, data, timestamp=None, context=None) -> TaggedArray:
    if not isinstance(data, list) or len(data) < 4:
        return self._empty_output()

    n_time = len(data[0])
    if n_time < 2:
        return self._empty_output()

    o1, h1, l1, c1 = self._get_ohlc(data, -2)
    o2, h2, l2, c2 = self._get_ohlc(data, -1)

    n_symbols = len(o2)
    exists = data[3][-1].exists
    valid = data[3][-1].valid
    result = np.zeros(n_symbols)

    for i in range(n_symbols):
        if exists[i] and valid[i] and not any(np.isnan([o1[i], c1[i], o2[i], c2[i]])):
            # Bearish first, bullish second opening below and closing above midpoint
            if (self._is_bearish(o1[i], c1[i]) and self._is_bullish(o2[i], c2[i]) and
                o2[i] < c1[i] and c2[i] > (o1[i] + c1[i]) / 2 and c2[i] < o1[i]):
                result[i] = 100.0

    result_valid = exists & valid
    return TaggedArray(
        value=result,
        exists=exists,
        valid=result_valid,
        updated=np.ones(n_symbols, dtype=bool),
    )

_{Source: apps/trading/operators/indicator/patterns.py}

---

CDLRICKSHAWMAN

Rickshaw Man - Doji with equal long shadows.

Example: pattern = CDLRICKSHAWMAN( Input(“FIELD:open”, timeframe=“1m”, lookback=5), Input(“FIELD:high”, timeframe=“1m”, lookback=5), Input(“FIELD:low”, timeframe=“1m”, lookback=5), Input(“FIELD:close”, timeframe=“1m”, lookback=5), )

Role: INDICATOR | Ephemeral: No

Parameters

Parameter	Type	Default	Description
open_	'Input'	Required
high	'Input'	Required
low	'Input'	Required
close	'Input'	Required

Usage

pattern = CDLRICKSHAWMAN(
    Input("FIELD:open", timeframe="1m", lookback=5),
    Input("FIELD:high", timeframe="1m", lookback=5),
    Input("FIELD:low", timeframe="1m", lookback=5),
    Input("FIELD:close", timeframe="1m", lookback=5),
)

Source Code

Full compute() implementation — no hidden logic.

def compute(self, data, timestamp=None, context=None) -> TaggedArray:
    if not isinstance(data, list) or len(data) < 4:
        return self._empty_output()

    n_time = len(data[0])
    if n_time == 0:
        return self._empty_output()

    o, h, l, c = self._get_ohlc(data)
    n_symbols = len(o)
    exists = data[3][-1].exists
    valid = data[3][-1].valid
    result = np.zeros(n_symbols)

    for i in range(n_symbols):
        if exists[i] and valid[i] and not any(np.isnan([o[i], h[i], l[i], c[i]])):
            body = self._body_size(o[i], c[i])
            range_size = h[i] - l[i]
            mid = (h[i] + l[i]) / 2
            body_mid = (o[i] + c[i]) / 2

            if range_size > 0:
                is_doji = body / range_size < 0.1
                is_centered = abs(body_mid - mid) < range_size * 0.1

                if is_doji and is_centered:
                    result[i] = 100.0

    result_valid = exists & valid
    return TaggedArray(
        value=result,
        exists=exists,
        valid=result_valid,
        updated=np.ones(n_symbols, dtype=bool),
    )

_{Source: apps/trading/operators/indicator/patterns.py}

---

CDLRISEFALL3METHODS

Rising/Falling Three Methods - Continuation pattern.

Example: pattern = CDLRISEFALL3METHODS( Input(“FIELD:open”, timeframe=“1m”, lookback=5), Input(“FIELD:high”, timeframe=“1m”, lookback=5), Input(“FIELD:low”, timeframe=“1m”, lookback=5), Input(“FIELD:close”, timeframe=“1m”, lookback=5), )

Role: INDICATOR | Ephemeral: No

Parameters

Parameter	Type	Default	Description
open_	'Input'	Required
high	'Input'	Required
low	'Input'	Required
close	'Input'	Required

Usage

pattern = CDLRISEFALL3METHODS(
    Input("FIELD:open", timeframe="1m", lookback=5),
    Input("FIELD:high", timeframe="1m", lookback=5),
    Input("FIELD:low", timeframe="1m", lookback=5),
    Input("FIELD:close", timeframe="1m", lookback=5),
)

Source Code

Full compute() implementation — no hidden logic.

def compute(self, data, timestamp=None, context=None) -> TaggedArray:
    if not isinstance(data, list) or len(data) < 4:
        return self._empty_output()

    n_time = len(data[0])
    if n_time < 5:
        return self._empty_output()

    n_symbols = len(data[0][-1].value)
    exists = data[3][-1].exists
    valid = data[3][-1].valid
    result = np.zeros(n_symbols)

    ohlc = [self._get_ohlc(data, -5+j) for j in range(5)]

    for i in range(n_symbols):
        if exists[i] and valid[i]:
            o = [ohlc[j][0][i] for j in range(5)]
            h = [ohlc[j][1][i] for j in range(5)]
            l = [ohlc[j][2][i] for j in range(5)]
            c = [ohlc[j][3][i] for j in range(5)]
            if any(np.isnan(o + h + l + c)):
                continue

            # Rising three methods
            if (self._is_bullish(o[0], c[0]) and
                all(self._is_bearish(o[j], c[j]) for j in [1, 2, 3]) and
                all(l[j] > l[0] for j in [1, 2, 3]) and
                self._is_bullish(o[4], c[4]) and c[4] > c[0]):
                result[i] = 100.0
            # Falling three methods
            elif (self._is_bearish(o[0], c[0]) and
                  all(self._is_bullish(o[j], c[j]) for j in [1, 2, 3]) and
                  all(h[j] < h[0] for j in [1, 2, 3]) and
                  self._is_bearish(o[4], c[4]) and c[4] < c[0]):
                result[i] = -100.0

    result_valid = exists & valid
    return TaggedArray(
        value=result,
        exists=exists,
        valid=result_valid,
        updated=np.ones(n_symbols, dtype=bool),
    )

_{Source: apps/trading/operators/indicator/patterns.py}

---

CDLSEPARATINGLINES

Separating Lines - Continuation pattern.

Example: pattern = CDLSEPARATINGLINES( Input(“FIELD:open”, timeframe=“1m”, lookback=5), Input(“FIELD:high”, timeframe=“1m”, lookback=5), Input(“FIELD:low”, timeframe=“1m”, lookback=5), Input(“FIELD:close”, timeframe=“1m”, lookback=5), )

Role: INDICATOR | Ephemeral: No

Parameters

Parameter	Type	Default	Description
open_	'Input'	Required
high	'Input'	Required
low	'Input'	Required
close	'Input'	Required

Usage

pattern = CDLSEPARATINGLINES(
    Input("FIELD:open", timeframe="1m", lookback=5),
    Input("FIELD:high", timeframe="1m", lookback=5),
    Input("FIELD:low", timeframe="1m", lookback=5),
    Input("FIELD:close", timeframe="1m", lookback=5),
)

Source Code

Full compute() implementation — no hidden logic.

def compute(self, data, timestamp=None, context=None) -> TaggedArray:
    if not isinstance(data, list) or len(data) < 4:
        return self._empty_output()

    n_time = len(data[0])
    if n_time < 2:
        return self._empty_output()

    o1, h1, l1, c1 = self._get_ohlc(data, -2)
    o2, h2, l2, c2 = self._get_ohlc(data, -1)

    n_symbols = len(o2)
    exists = data[3][-1].exists
    valid = data[3][-1].valid
    result = np.zeros(n_symbols)

    for i in range(n_symbols):
        if exists[i] and valid[i] and not any(np.isnan([o1[i], c1[i], o2[i], c2[i]])):
            # Same open, opposite direction
            if abs(o1[i] - o2[i]) < self._body_size(o1[i], c1[i]) * 0.05:
                if self._is_bearish(o1[i], c1[i]) and self._is_bullish(o2[i], c2[i]):
                    result[i] = 100.0
                elif self._is_bullish(o1[i], c1[i]) and self._is_bearish(o2[i], c2[i]):
                    result[i] = -100.0

    result_valid = exists & valid
    return TaggedArray(
        value=result,
        exists=exists,
        valid=result_valid,
        updated=np.ones(n_symbols, dtype=bool),
    )

_{Source: apps/trading/operators/indicator/patterns.py}

---

CDLSHORTLINE

Short Line Candle - Small body candle.

Example: pattern = CDLSHORTLINE( Input(“FIELD:open”, timeframe=“1m”, lookback=5), Input(“FIELD:high”, timeframe=“1m”, lookback=5), Input(“FIELD:low”, timeframe=“1m”, lookback=5), Input(“FIELD:close”, timeframe=“1m”, lookback=5), )

Role: INDICATOR | Ephemeral: No

Parameters

Parameter	Type	Default	Description
open_	'Input'	Required
high	'Input'	Required
low	'Input'	Required
close	'Input'	Required

Usage

pattern = CDLSHORTLINE(
    Input("FIELD:open", timeframe="1m", lookback=5),
    Input("FIELD:high", timeframe="1m", lookback=5),
    Input("FIELD:low", timeframe="1m", lookback=5),
    Input("FIELD:close", timeframe="1m", lookback=5),
)

Source Code

Full compute() implementation — no hidden logic.

def compute(self, data, timestamp=None, context=None) -> TaggedArray:
    if not isinstance(data, list) or len(data) < 4:
        return self._empty_output()

    n_time = len(data[0])
    if n_time == 0:
        return self._empty_output()

    o, h, l, c = self._get_ohlc(data)
    n_symbols = len(o)
    exists = data[3][-1].exists
    valid = data[3][-1].valid
    result = np.zeros(n_symbols)

    for i in range(n_symbols):
        if exists[i] and valid[i] and not any(np.isnan([o[i], h[i], l[i], c[i]])):
            body = self._body_size(o[i], c[i])
            range_size = h[i] - l[i]

            if range_size > 0 and body / range_size < 0.3 and body / range_size > 0.1:
                if self._is_bullish(o[i], c[i]):
                    result[i] = 100.0
                else:
                    result[i] = -100.0

    result_valid = exists & valid
    return TaggedArray(
        value=result,
        exists=exists,
        valid=result_valid,
        updated=np.ones(n_symbols, dtype=bool),
    )

_{Source: apps/trading/operators/indicator/patterns.py}

---

CDLSPINNINGTOP

Spinning Top - Small body with shadows.

Example: pattern = CDLSPINNINGTOP( Input(“FIELD:open”, timeframe=“1m”, lookback=5), Input(“FIELD:high”, timeframe=“1m”, lookback=5), Input(“FIELD:low”, timeframe=“1m”, lookback=5), Input(“FIELD:close”, timeframe=“1m”, lookback=5), )

Role: INDICATOR | Ephemeral: No

Parameters

Parameter	Type	Default	Description
open_	'Input'	Required
high	'Input'	Required
low	'Input'	Required
close	'Input'	Required

Usage

pattern = CDLSPINNINGTOP(
    Input("FIELD:open", timeframe="1m", lookback=5),
    Input("FIELD:high", timeframe="1m", lookback=5),
    Input("FIELD:low", timeframe="1m", lookback=5),
    Input("FIELD:close", timeframe="1m", lookback=5),
)

Source Code

Full compute() implementation — no hidden logic.

def compute(self, data, timestamp=None, context=None) -> TaggedArray:
    if not isinstance(data, list) or len(data) < 4:
        return self._empty_output()

    n_time = len(data[0])
    if n_time == 0:
        return self._empty_output()

    o, h, l, c = self._get_ohlc(data)
    n_symbols = len(o)
    exists = data[3][-1].exists
    valid = data[3][-1].valid
    result = np.zeros(n_symbols)

    for i in range(n_symbols):
        if exists[i] and valid[i] and not any(np.isnan([o[i], h[i], l[i], c[i]])):
            body = self._body_size(o[i], c[i])
            range_size = h[i] - l[i]
            upper_shadow = h[i] - max(o[i], c[i])
            lower_shadow = min(o[i], c[i]) - l[i]

            if range_size > 0 and body > 0:
                # Small body with shadows
                if (body / range_size < 0.4 and body / range_size > 0.1 and
                    upper_shadow > body * 0.3 and lower_shadow > body * 0.3):
                    result[i] = 100.0  # Indecision

    result_valid = exists & valid
    return TaggedArray(
        value=result,
        exists=exists,
        valid=result_valid,
        updated=np.ones(n_symbols, dtype=bool),
    )

_{Source: apps/trading/operators/indicator/patterns.py}

---

CDLSTALLEDPATTERN

Stalled Pattern - Bearish weakening.

Example: pattern = CDLSTALLEDPATTERN( Input(“FIELD:open”, timeframe=“1m”, lookback=5), Input(“FIELD:high”, timeframe=“1m”, lookback=5), Input(“FIELD:low”, timeframe=“1m”, lookback=5), Input(“FIELD:close”, timeframe=“1m”, lookback=5), )

Role: INDICATOR | Ephemeral: No

Parameters

Parameter	Type	Default	Description
open_	'Input'	Required
high	'Input'	Required
low	'Input'	Required
close	'Input'	Required

Usage

pattern = CDLSTALLEDPATTERN(
    Input("FIELD:open", timeframe="1m", lookback=5),
    Input("FIELD:high", timeframe="1m", lookback=5),
    Input("FIELD:low", timeframe="1m", lookback=5),
    Input("FIELD:close", timeframe="1m", lookback=5),
)

Source Code

Full compute() implementation — no hidden logic.

def compute(self, data, timestamp=None, context=None) -> TaggedArray:
    if not isinstance(data, list) or len(data) < 4:
        return self._empty_output()

    n_time = len(data[0])
    if n_time < 3:
        return self._empty_output()

    o1, h1, l1, c1 = self._get_ohlc(data, -3)
    o2, h2, l2, c2 = self._get_ohlc(data, -2)
    o3, h3, l3, c3 = self._get_ohlc(data, -1)

    n_symbols = len(o3)
    exists = data[3][-1].exists
    valid = data[3][-1].valid
    result = np.zeros(n_symbols)

    for i in range(n_symbols):
        if exists[i] and valid[i]:
            if any(np.isnan([o1[i], c1[i], o2[i], c2[i], o3[i], c3[i]])):
                continue
            body1 = self._body_size(o1[i], c1[i])
            body2 = self._body_size(o2[i], c2[i])
            body3 = self._body_size(o3[i], c3[i])

            # Three bullish with decreasing bodies
            if (self._is_bullish(o1[i], c1[i]) and self._is_bullish(o2[i], c2[i]) and
                self._is_bullish(o3[i], c3[i]) and body3 < body2 and body2 < body1 * 0.7):
                result[i] = -100.0

    result_valid = exists & valid
    return TaggedArray(
        value=result,
        exists=exists,
        valid=result_valid,
        updated=np.ones(n_symbols, dtype=bool),
    )

_{Source: apps/trading/operators/indicator/patterns.py}

---

CDLSTICKSANDWICH

Stick Sandwich - Bullish reversal.

Example: pattern = CDLSTICKSANDWICH( Input(“FIELD:open”, timeframe=“1m”, lookback=5), Input(“FIELD:high”, timeframe=“1m”, lookback=5), Input(“FIELD:low”, timeframe=“1m”, lookback=5), Input(“FIELD:close”, timeframe=“1m”, lookback=5), )

Role: INDICATOR | Ephemeral: No

Parameters

Parameter	Type	Default	Description
open_	'Input'	Required
high	'Input'	Required
low	'Input'	Required
close	'Input'	Required

Usage

pattern = CDLSTICKSANDWICH(
    Input("FIELD:open", timeframe="1m", lookback=5),
    Input("FIELD:high", timeframe="1m", lookback=5),
    Input("FIELD:low", timeframe="1m", lookback=5),
    Input("FIELD:close", timeframe="1m", lookback=5),
)

Source Code

Full compute() implementation — no hidden logic.

def compute(self, data, timestamp=None, context=None) -> TaggedArray:
    if not isinstance(data, list) or len(data) < 4:
        return self._empty_output()

    n_time = len(data[0])
    if n_time < 3:
        return self._empty_output()

    o1, h1, l1, c1 = self._get_ohlc(data, -3)
    o2, h2, l2, c2 = self._get_ohlc(data, -2)
    o3, h3, l3, c3 = self._get_ohlc(data, -1)

    n_symbols = len(o3)
    exists = data[3][-1].exists
    valid = data[3][-1].valid
    result = np.zeros(n_symbols)

    for i in range(n_symbols):
        if exists[i] and valid[i]:
            if any(np.isnan([o1[i], c1[i], o2[i], c2[i], o3[i], c3[i]])):
                continue
            # Bearish, bullish, bearish with matching closes
            if (self._is_bearish(o1[i], c1[i]) and self._is_bullish(o2[i], c2[i]) and
                self._is_bearish(o3[i], c3[i]) and
                abs(c1[i] - c3[i]) < self._body_size(o1[i], c1[i]) * 0.1):
                result[i] = 100.0

    result_valid = exists & valid
    return TaggedArray(
        value=result,
        exists=exists,
        valid=result_valid,
        updated=np.ones(n_symbols, dtype=bool),
    )

_{Source: apps/trading/operators/indicator/patterns.py}

---

CDLTAKURI

Takuri (Dragonfly Doji with very long lower shadow).

Example: pattern = CDLTAKURI( Input(“FIELD:open”, timeframe=“1m”, lookback=5), Input(“FIELD:high”, timeframe=“1m”, lookback=5), Input(“FIELD:low”, timeframe=“1m”, lookback=5), Input(“FIELD:close”, timeframe=“1m”, lookback=5), )

Role: INDICATOR | Ephemeral: No

Parameters

Parameter	Type	Default	Description
open_	'Input'	Required
high	'Input'	Required
low	'Input'	Required
close	'Input'	Required

Usage

pattern = CDLTAKURI(
    Input("FIELD:open", timeframe="1m", lookback=5),
    Input("FIELD:high", timeframe="1m", lookback=5),
    Input("FIELD:low", timeframe="1m", lookback=5),
    Input("FIELD:close", timeframe="1m", lookback=5),
)

Source Code

Full compute() implementation — no hidden logic.

def compute(self, data, timestamp=None, context=None) -> TaggedArray:
    if not isinstance(data, list) or len(data) < 4:
        return self._empty_output()

    n_time = len(data[0])
    if n_time == 0:
        return self._empty_output()

    o, h, l, c = self._get_ohlc(data)
    n_symbols = len(o)
    exists = data[3][-1].exists
    valid = data[3][-1].valid
    result = np.zeros(n_symbols)

    for i in range(n_symbols):
        if exists[i] and valid[i] and not any(np.isnan([o[i], h[i], l[i], c[i]])):
            body = self._body_size(o[i], c[i])
            range_size = h[i] - l[i]
            lower_shadow = min(o[i], c[i]) - l[i]
            upper_shadow = h[i] - max(o[i], c[i])

            if range_size > 0:
                is_doji_like = body / range_size < 0.15
                has_very_long_lower = lower_shadow > range_size * 0.7
                has_tiny_upper = upper_shadow < range_size * 0.05

                if is_doji_like and has_very_long_lower and has_tiny_upper:
                    result[i] = 100.0

    result_valid = exists & valid
    return TaggedArray(
        value=result,
        exists=exists,
        valid=result_valid,
        updated=np.ones(n_symbols, dtype=bool),
    )

_{Source: apps/trading/operators/indicator/patterns.py}

---

CDLTASUKIGAP

Tasuki Gap - Continuation pattern.

Example: pattern = CDLTASUKIGAP( Input(“FIELD:open”, timeframe=“1m”, lookback=5), Input(“FIELD:high”, timeframe=“1m”, lookback=5), Input(“FIELD:low”, timeframe=“1m”, lookback=5), Input(“FIELD:close”, timeframe=“1m”, lookback=5), )

Role: INDICATOR | Ephemeral: No

Parameters

Parameter	Type	Default	Description
open_	'Input'	Required
high	'Input'	Required
low	'Input'	Required
close	'Input'	Required

Usage

pattern = CDLTASUKIGAP(
    Input("FIELD:open", timeframe="1m", lookback=5),
    Input("FIELD:high", timeframe="1m", lookback=5),
    Input("FIELD:low", timeframe="1m", lookback=5),
    Input("FIELD:close", timeframe="1m", lookback=5),
)

Source Code

Full compute() implementation — no hidden logic.

def compute(self, data, timestamp=None, context=None) -> TaggedArray:
    if not isinstance(data, list) or len(data) < 4:
        return self._empty_output()

    n_time = len(data[0])
    if n_time < 3:
        return self._empty_output()

    o1, h1, l1, c1 = self._get_ohlc(data, -3)
    o2, h2, l2, c2 = self._get_ohlc(data, -2)
    o3, h3, l3, c3 = self._get_ohlc(data, -1)

    n_symbols = len(o3)
    exists = data[3][-1].exists
    valid = data[3][-1].valid
    result = np.zeros(n_symbols)

    for i in range(n_symbols):
        if exists[i] and valid[i]:
            if any(np.isnan([o1[i], h1[i], l1[i], c1[i], o2[i], h2[i], l2[i], c2[i], o3[i], c3[i]])):
                continue
            # Upside tasuki gap
            if (self._is_bullish(o1[i], c1[i]) and self._is_bullish(o2[i], c2[i]) and
                l2[i] > h1[i] and  # Gap
                self._is_bearish(o3[i], c3[i]) and o3[i] < c2[i] and c3[i] > l2[i]):
                result[i] = 100.0
            # Downside tasuki gap
            elif (self._is_bearish(o1[i], c1[i]) and self._is_bearish(o2[i], c2[i]) and
                  h2[i] < l1[i] and  # Gap
                  self._is_bullish(o3[i], c3[i]) and o3[i] > c2[i] and c3[i] < h2[i]):
                result[i] = -100.0

    result_valid = exists & valid
    return TaggedArray(
        value=result,
        exists=exists,
        valid=result_valid,
        updated=np.ones(n_symbols, dtype=bool),
    )

_{Source: apps/trading/operators/indicator/patterns.py}

---

CDLTHRUSTING

Thrusting Pattern - Bearish continuation.

Example: pattern = CDLTHRUSTING( Input(“FIELD:open”, timeframe=“1m”, lookback=5), Input(“FIELD:high”, timeframe=“1m”, lookback=5), Input(“FIELD:low”, timeframe=“1m”, lookback=5), Input(“FIELD:close”, timeframe=“1m”, lookback=5), )

Role: INDICATOR | Ephemeral: No

Parameters

Parameter	Type	Default	Description
open_	'Input'	Required
high	'Input'	Required
low	'Input'	Required
close	'Input'	Required

Usage

pattern = CDLTHRUSTING(
    Input("FIELD:open", timeframe="1m", lookback=5),
    Input("FIELD:high", timeframe="1m", lookback=5),
    Input("FIELD:low", timeframe="1m", lookback=5),
    Input("FIELD:close", timeframe="1m", lookback=5),
)

Source Code

Full compute() implementation — no hidden logic.

def compute(self, data, timestamp=None, context=None) -> TaggedArray:
    if not isinstance(data, list) or len(data) < 4:
        return self._empty_output()

    n_time = len(data[0])
    if n_time < 2:
        return self._empty_output()

    o1, h1, l1, c1 = self._get_ohlc(data, -2)
    o2, h2, l2, c2 = self._get_ohlc(data, -1)

    n_symbols = len(o2)
    exists = data[3][-1].exists
    valid = data[3][-1].valid
    result = np.zeros(n_symbols)

    for i in range(n_symbols):
        if exists[i] and valid[i] and not any(np.isnan([o1[i], c1[i], o2[i], c2[i]])):
            # Bearish first, bullish second closing below midpoint
            midpoint = (o1[i] + c1[i]) / 2
            if (self._is_bearish(o1[i], c1[i]) and self._is_bullish(o2[i], c2[i]) and
                o2[i] < c1[i] and c2[i] < midpoint and c2[i] > c1[i]):
                result[i] = -100.0

    result_valid = exists & valid
    return TaggedArray(
        value=result,
        exists=exists,
        valid=result_valid,
        updated=np.ones(n_symbols, dtype=bool),
    )

_{Source: apps/trading/operators/indicator/patterns.py}

---

CDLTRISTAR

Tristar Pattern - Three doji reversal.

Example: pattern = CDLTRISTAR( Input(“FIELD:open”, timeframe=“1m”, lookback=5), Input(“FIELD:high”, timeframe=“1m”, lookback=5), Input(“FIELD:low”, timeframe=“1m”, lookback=5), Input(“FIELD:close”, timeframe=“1m”, lookback=5), )

Role: INDICATOR | Ephemeral: No

Parameters

Parameter	Type	Default	Description
open_	'Input'	Required
high	'Input'	Required
low	'Input'	Required
close	'Input'	Required

Usage

pattern = CDLTRISTAR(
    Input("FIELD:open", timeframe="1m", lookback=5),
    Input("FIELD:high", timeframe="1m", lookback=5),
    Input("FIELD:low", timeframe="1m", lookback=5),
    Input("FIELD:close", timeframe="1m", lookback=5),
)

Source Code

Full compute() implementation — no hidden logic.

def compute(self, data, timestamp=None, context=None) -> TaggedArray:
    if not isinstance(data, list) or len(data) < 4:
        return self._empty_output()

    n_time = len(data[0])
    if n_time < 3:
        return self._empty_output()

    o1, h1, l1, c1 = self._get_ohlc(data, -3)
    o2, h2, l2, c2 = self._get_ohlc(data, -2)
    o3, h3, l3, c3 = self._get_ohlc(data, -1)

    n_symbols = len(o3)
    exists = data[3][-1].exists
    valid = data[3][-1].valid
    result = np.zeros(n_symbols)

    for i in range(n_symbols):
        if exists[i] and valid[i]:
            if any(np.isnan([o1[i], h1[i], l1[i], c1[i], o2[i], h2[i], l2[i], c2[i], o3[i], h3[i], l3[i], c3[i]])):
                continue

            def is_doji(o, h, l, c):
                body = abs(c - o)
                range_size = h - l
                return range_size > 0 and body / range_size < 0.1

            if is_doji(o1[i], h1[i], l1[i], c1[i]) and is_doji(o2[i], h2[i], l2[i], c2[i]) and is_doji(o3[i], h3[i], l3[i], c3[i]):
                mid1 = (o1[i] + c1[i]) / 2
                mid2 = (o2[i] + c2[i]) / 2
                mid3 = (o3[i] + c3[i]) / 2
                # Gap pattern
                if mid2 < mid1 and mid2 < mid3:
                    result[i] = 100.0  # Bullish
                elif mid2 > mid1 and mid2 > mid3:
                    result[i] = -100.0  # Bearish

    result_valid = exists & valid
    return TaggedArray(
        value=result,
        exists=exists,
        valid=result_valid,
        updated=np.ones(n_symbols, dtype=bool),
    )

_{Source: apps/trading/operators/indicator/patterns.py}

---

CDLUNIQUE3RIVER

Unique 3 River - Bullish reversal.

Example: pattern = CDLUNIQUE3RIVER( Input(“FIELD:open”, timeframe=“1m”, lookback=5), Input(“FIELD:high”, timeframe=“1m”, lookback=5), Input(“FIELD:low”, timeframe=“1m”, lookback=5), Input(“FIELD:close”, timeframe=“1m”, lookback=5), )

Role: INDICATOR | Ephemeral: No

Parameters

Parameter	Type	Default	Description
open_	'Input'	Required
high	'Input'	Required
low	'Input'	Required
close	'Input'	Required

Usage

pattern = CDLUNIQUE3RIVER(
    Input("FIELD:open", timeframe="1m", lookback=5),
    Input("FIELD:high", timeframe="1m", lookback=5),
    Input("FIELD:low", timeframe="1m", lookback=5),
    Input("FIELD:close", timeframe="1m", lookback=5),
)

Source Code

Full compute() implementation — no hidden logic.

def compute(self, data, timestamp=None, context=None) -> TaggedArray:
    if not isinstance(data, list) or len(data) < 4:
        return self._empty_output()

    n_time = len(data[0])
    if n_time < 3:
        return self._empty_output()

    o1, h1, l1, c1 = self._get_ohlc(data, -3)
    o2, h2, l2, c2 = self._get_ohlc(data, -2)
    o3, h3, l3, c3 = self._get_ohlc(data, -1)

    n_symbols = len(o3)
    exists = data[3][-1].exists
    valid = data[3][-1].valid
    result = np.zeros(n_symbols)

    for i in range(n_symbols):
        if exists[i] and valid[i]:
            if any(np.isnan([o1[i], l1[i], c1[i], o2[i], l2[i], c2[i], o3[i], c3[i]])):
                continue
            # Long bearish, small bearish with lower low, small bullish
            if (self._is_bearish(o1[i], c1[i]) and
                self._is_bearish(o2[i], c2[i]) and l2[i] < l1[i] and
                self._body_size(o2[i], c2[i]) < self._body_size(o1[i], c1[i]) * 0.5 and
                self._is_bullish(o3[i], c3[i]) and c3[i] < c2[i]):
                result[i] = 100.0

    result_valid = exists & valid
    return TaggedArray(
        value=result,
        exists=exists,
        valid=result_valid,
        updated=np.ones(n_symbols, dtype=bool),
    )

_{Source: apps/trading/operators/indicator/patterns.py}

---

CDLUPSIDEGAP2CROWS

Upside Gap Two Crows - Bearish reversal.

Example: pattern = CDLUPSIDEGAP2CROWS( Input(“FIELD:open”, timeframe=“1m”, lookback=5), Input(“FIELD:high”, timeframe=“1m”, lookback=5), Input(“FIELD:low”, timeframe=“1m”, lookback=5), Input(“FIELD:close”, timeframe=“1m”, lookback=5), )

Role: INDICATOR | Ephemeral: No

Parameters

Parameter	Type	Default	Description
open_	'Input'	Required
high	'Input'	Required
low	'Input'	Required
close	'Input'	Required

Usage

pattern = CDLUPSIDEGAP2CROWS(
    Input("FIELD:open", timeframe="1m", lookback=5),
    Input("FIELD:high", timeframe="1m", lookback=5),
    Input("FIELD:low", timeframe="1m", lookback=5),
    Input("FIELD:close", timeframe="1m", lookback=5),
)

Source Code

Full compute() implementation — no hidden logic.

def compute(self, data, timestamp=None, context=None) -> TaggedArray:
    if not isinstance(data, list) or len(data) < 4:
        return self._empty_output()

    n_time = len(data[0])
    if n_time < 3:
        return self._empty_output()

    o1, h1, l1, c1 = self._get_ohlc(data, -3)
    o2, h2, l2, c2 = self._get_ohlc(data, -2)
    o3, h3, l3, c3 = self._get_ohlc(data, -1)

    n_symbols = len(o3)
    exists = data[3][-1].exists
    valid = data[3][-1].valid
    result = np.zeros(n_symbols)

    for i in range(n_symbols):
        if exists[i] and valid[i]:
            if any(np.isnan([o1[i], c1[i], o2[i], c2[i], o3[i], c3[i]])):
                continue
            # Bullish, small bearish gap up, larger bearish engulfing second
            if (self._is_bullish(o1[i], c1[i]) and
                self._is_bearish(o2[i], c2[i]) and o2[i] > c1[i] and
                self._is_bearish(o3[i], c3[i]) and o3[i] > o2[i] and c3[i] < c2[i] and c3[i] > c1[i]):
                result[i] = -100.0

    result_valid = exists & valid
    return TaggedArray(
        value=result,
        exists=exists,
        valid=result_valid,
        updated=np.ones(n_symbols, dtype=bool),
    )

_{Source: apps/trading/operators/indicator/patterns.py}

---

CDLXSIDEGAP3METHODS

Upside/Downside Gap Three Methods - Continuation.

Example: pattern = CDLXSIDEGAP3METHODS( Input(“FIELD:open”, timeframe=“1m”, lookback=5), Input(“FIELD:high”, timeframe=“1m”, lookback=5), Input(“FIELD:low”, timeframe=“1m”, lookback=5), Input(“FIELD:close”, timeframe=“1m”, lookback=5), )

Role: INDICATOR | Ephemeral: No

Parameters

Parameter	Type	Default	Description
open_	'Input'	Required
high	'Input'	Required
low	'Input'	Required
close	'Input'	Required

Usage

pattern = CDLXSIDEGAP3METHODS(
    Input("FIELD:open", timeframe="1m", lookback=5),
    Input("FIELD:high", timeframe="1m", lookback=5),
    Input("FIELD:low", timeframe="1m", lookback=5),
    Input("FIELD:close", timeframe="1m", lookback=5),
)

Source Code

Full compute() implementation — no hidden logic.

def compute(self, data, timestamp=None, context=None) -> TaggedArray:
    if not isinstance(data, list) or len(data) < 4:
        return self._empty_output()

    n_time = len(data[0])
    if n_time < 3:
        return self._empty_output()

    o1, h1, l1, c1 = self._get_ohlc(data, -3)
    o2, h2, l2, c2 = self._get_ohlc(data, -2)
    o3, h3, l3, c3 = self._get_ohlc(data, -1)

    n_symbols = len(o3)
    exists = data[3][-1].exists
    valid = data[3][-1].valid
    result = np.zeros(n_symbols)

    for i in range(n_symbols):
        if exists[i] and valid[i]:
            if any(np.isnan([o1[i], h1[i], l1[i], c1[i], o2[i], h2[i], l2[i], c2[i], o3[i], c3[i]])):
                continue
            # Upside gap three methods
            if (self._is_bullish(o1[i], c1[i]) and self._is_bullish(o2[i], c2[i]) and
                l2[i] > h1[i] and  # Gap up
                self._is_bearish(o3[i], c3[i]) and o3[i] > l2[i] and c3[i] < h1[i]):
                result[i] = 100.0
            # Downside gap three methods
            elif (self._is_bearish(o1[i], c1[i]) and self._is_bearish(o2[i], c2[i]) and
                  h2[i] < l1[i] and  # Gap down
                  self._is_bullish(o3[i], c3[i]) and o3[i] < h2[i] and c3[i] > l1[i]):
                result[i] = -100.0

    result_valid = exists & valid
    return TaggedArray(
        value=result,
        exists=exists,
        valid=result_valid,
        updated=np.ones(n_symbols, dtype=bool),
    )

_{Source: apps/trading/operators/indicator/patterns.py}

Related Pages

Operator Protocol

How operators implement the compute() interface

StatefulGraph

How operators compose into a DAG