1960 lines
47 KiB
Python
1960 lines
47 KiB
Python
"""
|
|
Pattern Recognition — Candlestick pattern detection.
|
|
|
|
All functions return an integer array where:
|
|
100 = bullish signal
|
|
-100 = bearish signal
|
|
0 = no pattern detected
|
|
|
|
Functions
|
|
---------
|
|
CDL2CROWS — Two Crows (bearish)
|
|
CDL3BLACKCROWS — Three Black Crows (bearish)
|
|
CDL3WHITESOLDIERS — Three White Soldiers (bullish)
|
|
CDL3INSIDE — Three Inside Up/Down
|
|
CDL3OUTSIDE — Three Outside Up/Down
|
|
CDLDOJI — Doji
|
|
CDLDOJISTAR — Doji Star
|
|
CDLENGULFING — Engulfing Pattern
|
|
CDLHAMMER — Hammer (bullish)
|
|
CDLHARAMI — Harami Pattern
|
|
CDLHARAMICROSS — Harami Cross Pattern
|
|
CDLMARUBOZU — Marubozu
|
|
CDLMORNINGSTAR — Morning Star (bullish, 3-candle)
|
|
CDLMORNINGDOJISTAR — Morning Doji Star (bullish, 3-candle)
|
|
CDLEVENINGSTAR — Evening Star (bearish, 3-candle)
|
|
CDLEVENINGDOJISTAR — Evening Doji Star (bearish, 3-candle)
|
|
CDLSHOOTINGSTAR — Shooting Star (bearish)
|
|
CDLSPINNINGTOP — Spinning Top
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import numpy as np
|
|
from numpy.typing import ArrayLike
|
|
|
|
from ferro_ta._ferro_ta import (
|
|
cdl2crows as _cdl2crows,
|
|
)
|
|
from ferro_ta._ferro_ta import (
|
|
cdl3blackcrows as _cdl3blackcrows,
|
|
)
|
|
from ferro_ta._ferro_ta import (
|
|
cdl3inside as _cdl3inside,
|
|
)
|
|
from ferro_ta._ferro_ta import (
|
|
cdl3linestrike as _cdl3linestrike,
|
|
)
|
|
from ferro_ta._ferro_ta import (
|
|
cdl3outside as _cdl3outside,
|
|
)
|
|
from ferro_ta._ferro_ta import (
|
|
cdl3starsinsouth as _cdl3starsinsouth,
|
|
)
|
|
from ferro_ta._ferro_ta import (
|
|
cdl3whitesoldiers as _cdl3whitesoldiers,
|
|
)
|
|
from ferro_ta._ferro_ta import (
|
|
cdlabandonedbaby as _cdlabandonedbaby,
|
|
)
|
|
from ferro_ta._ferro_ta import (
|
|
cdladvanceblock as _cdladvanceblock,
|
|
)
|
|
from ferro_ta._ferro_ta import (
|
|
cdlbelthold as _cdlbelthold,
|
|
)
|
|
from ferro_ta._ferro_ta import (
|
|
cdlbreakaway as _cdlbreakaway,
|
|
)
|
|
from ferro_ta._ferro_ta import (
|
|
cdlclosingmarubozu as _cdlclosingmarubozu,
|
|
)
|
|
from ferro_ta._ferro_ta import (
|
|
cdlconcealbabyswall as _cdlconcealbabyswall,
|
|
)
|
|
from ferro_ta._ferro_ta import (
|
|
cdlcounterattack as _cdlcounterattack,
|
|
)
|
|
from ferro_ta._ferro_ta import (
|
|
cdldarkcloudcover as _cdldarkcloudcover,
|
|
)
|
|
from ferro_ta._ferro_ta import (
|
|
cdldoji as _cdldoji,
|
|
)
|
|
from ferro_ta._ferro_ta import (
|
|
cdldojistar as _cdldojistar,
|
|
)
|
|
from ferro_ta._ferro_ta import (
|
|
cdldragonflydoji as _cdldragonflydoji,
|
|
)
|
|
from ferro_ta._ferro_ta import (
|
|
cdlengulfing as _cdlengulfing,
|
|
)
|
|
from ferro_ta._ferro_ta import (
|
|
cdleveningdojistar as _cdleveningdojistar,
|
|
)
|
|
from ferro_ta._ferro_ta import (
|
|
cdleveningstar as _cdleveningstar,
|
|
)
|
|
from ferro_ta._ferro_ta import (
|
|
cdlgapsidesidewhite as _cdlgapsidesidewhite,
|
|
)
|
|
from ferro_ta._ferro_ta import (
|
|
cdlgravestonedoji as _cdlgravestonedoji,
|
|
)
|
|
from ferro_ta._ferro_ta import (
|
|
cdlhammer as _cdlhammer,
|
|
)
|
|
from ferro_ta._ferro_ta import (
|
|
cdlhangingman as _cdlhangingman,
|
|
)
|
|
from ferro_ta._ferro_ta import (
|
|
cdlharami as _cdlharami,
|
|
)
|
|
from ferro_ta._ferro_ta import (
|
|
cdlharamicross as _cdlharamicross,
|
|
)
|
|
from ferro_ta._ferro_ta import (
|
|
cdlhighwave as _cdlhighwave,
|
|
)
|
|
from ferro_ta._ferro_ta import (
|
|
cdlhikkake as _cdlhikkake,
|
|
)
|
|
from ferro_ta._ferro_ta import (
|
|
cdlhikkakemod as _cdlhikkakemod,
|
|
)
|
|
from ferro_ta._ferro_ta import (
|
|
cdlhomingpigeon as _cdlhomingpigeon,
|
|
)
|
|
from ferro_ta._ferro_ta import (
|
|
cdlidentical3crows as _cdlidentical3crows,
|
|
)
|
|
from ferro_ta._ferro_ta import (
|
|
cdlinneck as _cdlinneck,
|
|
)
|
|
from ferro_ta._ferro_ta import (
|
|
cdlinvertedhammer as _cdlinvertedhammer,
|
|
)
|
|
from ferro_ta._ferro_ta import (
|
|
cdlkicking as _cdlkicking,
|
|
)
|
|
from ferro_ta._ferro_ta import (
|
|
cdlkickingbylength as _cdlkickingbylength,
|
|
)
|
|
from ferro_ta._ferro_ta import (
|
|
cdlladderbottom as _cdlladderbottom,
|
|
)
|
|
from ferro_ta._ferro_ta import (
|
|
cdllongleggeddoji as _cdllongleggeddoji,
|
|
)
|
|
from ferro_ta._ferro_ta import (
|
|
cdllongline as _cdllongline,
|
|
)
|
|
from ferro_ta._ferro_ta import (
|
|
cdlmarubozu as _cdlmarubozu,
|
|
)
|
|
from ferro_ta._ferro_ta import (
|
|
cdlmatchinglow as _cdlmatchinglow,
|
|
)
|
|
from ferro_ta._ferro_ta import (
|
|
cdlmathold as _cdlmathold,
|
|
)
|
|
from ferro_ta._ferro_ta import (
|
|
cdlmorningdojistar as _cdlmorningdojistar,
|
|
)
|
|
from ferro_ta._ferro_ta import (
|
|
cdlmorningstar as _cdlmorningstar,
|
|
)
|
|
from ferro_ta._ferro_ta import (
|
|
cdlonneck as _cdlonneck,
|
|
)
|
|
from ferro_ta._ferro_ta import (
|
|
cdlpiercing as _cdlpiercing,
|
|
)
|
|
from ferro_ta._ferro_ta import (
|
|
cdlrickshawman as _cdlrickshawman,
|
|
)
|
|
from ferro_ta._ferro_ta import (
|
|
cdlrisefall3methods as _cdlrisefall3methods,
|
|
)
|
|
from ferro_ta._ferro_ta import (
|
|
cdlseparatinglines as _cdlseparatinglines,
|
|
)
|
|
from ferro_ta._ferro_ta import (
|
|
cdlshootingstar as _cdlshootingstar,
|
|
)
|
|
from ferro_ta._ferro_ta import (
|
|
cdlshortline as _cdlshortline,
|
|
)
|
|
from ferro_ta._ferro_ta import (
|
|
cdlspinningtop as _cdlspinningtop,
|
|
)
|
|
from ferro_ta._ferro_ta import (
|
|
cdlstalledpattern as _cdlstalledpattern,
|
|
)
|
|
from ferro_ta._ferro_ta import (
|
|
cdlsticksandwich as _cdlsticksandwich,
|
|
)
|
|
from ferro_ta._ferro_ta import (
|
|
cdltakuri as _cdltakuri,
|
|
)
|
|
from ferro_ta._ferro_ta import (
|
|
cdltasukigap as _cdltasukigap,
|
|
)
|
|
from ferro_ta._ferro_ta import (
|
|
cdlthrusting as _cdlthrusting,
|
|
)
|
|
from ferro_ta._ferro_ta import (
|
|
cdltristar as _cdltristar,
|
|
)
|
|
from ferro_ta._ferro_ta import (
|
|
cdlunique3river as _cdlunique3river,
|
|
)
|
|
from ferro_ta._ferro_ta import (
|
|
cdlupsidegap2crows as _cdlupsidegap2crows,
|
|
)
|
|
from ferro_ta._ferro_ta import (
|
|
cdlxsidegap3methods as _cdlxsidegap3methods,
|
|
)
|
|
from ferro_ta._utils import _to_f64
|
|
from ferro_ta.core.exceptions import FerroTAInputError, _normalize_rust_error
|
|
|
|
|
|
def _validate_ohlc_lengths(o, h, lo, c) -> None:
|
|
if not (len(o) == len(h) == len(lo) == len(c)):
|
|
raise FerroTAInputError(
|
|
f"All OHLC arrays must have the same length "
|
|
f"(open={len(o)}, high={len(h)}, low={len(lo)}, close={len(c)}).",
|
|
)
|
|
|
|
|
|
def CDL2CROWS(
|
|
open: ArrayLike,
|
|
high: ArrayLike,
|
|
low: ArrayLike,
|
|
close: ArrayLike,
|
|
) -> np.ndarray:
|
|
"""Two Crows — bearish 3-candle reversal pattern.
|
|
|
|
Parameters
|
|
----------
|
|
open, high, low, close : array-like
|
|
OHLC price arrays.
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray[int32]
|
|
-100 where pattern is detected, 0 otherwise.
|
|
"""
|
|
o, h, lo, c = _to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
_validate_ohlc_lengths(o, h, lo, c)
|
|
try:
|
|
return _cdl2crows(o, h, lo, c)
|
|
except ValueError as e:
|
|
_normalize_rust_error(e)
|
|
|
|
|
|
def CDLDOJI(
|
|
open: ArrayLike,
|
|
high: ArrayLike,
|
|
low: ArrayLike,
|
|
close: ArrayLike,
|
|
) -> np.ndarray:
|
|
"""Doji — open ≈ close, reflecting market indecision.
|
|
|
|
Parameters
|
|
----------
|
|
open, high, low, close : array-like
|
|
OHLC price arrays.
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray[int32]
|
|
100 where pattern is detected, 0 otherwise.
|
|
"""
|
|
o, h, lo, c = _to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
_validate_ohlc_lengths(o, h, lo, c)
|
|
try:
|
|
return _cdldoji(o, h, lo, c)
|
|
except ValueError as e:
|
|
_normalize_rust_error(e)
|
|
|
|
|
|
def CDLENGULFING(
|
|
open: ArrayLike,
|
|
high: ArrayLike,
|
|
low: ArrayLike,
|
|
close: ArrayLike,
|
|
) -> np.ndarray:
|
|
"""Engulfing Pattern.
|
|
|
|
Parameters
|
|
----------
|
|
open, high, low, close : array-like
|
|
OHLC price arrays.
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray[int32]
|
|
100 (bullish), -100 (bearish), or 0.
|
|
"""
|
|
o, h, lo, c = _to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
_validate_ohlc_lengths(o, h, lo, c)
|
|
try:
|
|
return _cdlengulfing(o, h, lo, c)
|
|
except ValueError as e:
|
|
_normalize_rust_error(e)
|
|
|
|
|
|
def CDLHAMMER(
|
|
open: ArrayLike,
|
|
high: ArrayLike,
|
|
low: ArrayLike,
|
|
close: ArrayLike,
|
|
) -> np.ndarray:
|
|
"""Hammer — small body at top, long lower shadow.
|
|
|
|
Parameters
|
|
----------
|
|
open, high, low, close : array-like
|
|
OHLC price arrays.
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray[int32]
|
|
100 where pattern is detected, 0 otherwise.
|
|
"""
|
|
o, h, lo, c = _to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
_validate_ohlc_lengths(o, h, lo, c)
|
|
try:
|
|
return _cdlhammer(o, h, lo, c)
|
|
except ValueError as e:
|
|
_normalize_rust_error(e)
|
|
|
|
|
|
def CDLSHOOTINGSTAR(
|
|
open: ArrayLike,
|
|
high: ArrayLike,
|
|
low: ArrayLike,
|
|
close: ArrayLike,
|
|
) -> np.ndarray:
|
|
"""Shooting Star — small body at bottom, long upper shadow.
|
|
|
|
Parameters
|
|
----------
|
|
open, high, low, close : array-like
|
|
OHLC price arrays.
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray[int32]
|
|
-100 where pattern is detected, 0 otherwise.
|
|
"""
|
|
o, h, lo, c = _to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
_validate_ohlc_lengths(o, h, lo, c)
|
|
try:
|
|
return _cdlshootingstar(
|
|
_to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
)
|
|
except ValueError as e:
|
|
_normalize_rust_error(e)
|
|
|
|
|
|
def CDLMORNINGSTAR(
|
|
open: ArrayLike,
|
|
high: ArrayLike,
|
|
low: ArrayLike,
|
|
close: ArrayLike,
|
|
) -> np.ndarray:
|
|
"""Morning Star — 3-candle bullish reversal pattern.
|
|
|
|
Parameters
|
|
----------
|
|
open, high, low, close : array-like
|
|
OHLC price arrays.
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray[int32]
|
|
100 where pattern is detected, 0 otherwise.
|
|
"""
|
|
o, h, lo, c = _to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
_validate_ohlc_lengths(o, h, lo, c)
|
|
try:
|
|
return _cdlmorningstar(
|
|
_to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
)
|
|
except ValueError as e:
|
|
_normalize_rust_error(e)
|
|
|
|
|
|
def CDLEVENINGSTAR(
|
|
open: ArrayLike,
|
|
high: ArrayLike,
|
|
low: ArrayLike,
|
|
close: ArrayLike,
|
|
) -> np.ndarray:
|
|
"""Evening Star — 3-candle bearish reversal pattern.
|
|
|
|
Parameters
|
|
----------
|
|
open, high, low, close : array-like
|
|
OHLC price arrays.
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray[int32]
|
|
-100 where pattern is detected, 0 otherwise.
|
|
"""
|
|
o, h, lo, c = _to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
_validate_ohlc_lengths(o, h, lo, c)
|
|
try:
|
|
return _cdleveningstar(
|
|
_to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
)
|
|
except ValueError as e:
|
|
_normalize_rust_error(e)
|
|
|
|
|
|
def CDLMARUBOZU(
|
|
open: ArrayLike,
|
|
high: ArrayLike,
|
|
low: ArrayLike,
|
|
close: ArrayLike,
|
|
) -> np.ndarray:
|
|
"""Marubozu — full body candle with no or minimal shadows.
|
|
|
|
Parameters
|
|
----------
|
|
open, high, low, close : array-like
|
|
OHLC price arrays.
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray[int32]
|
|
100 (bullish), -100 (bearish), or 0.
|
|
"""
|
|
o, h, lo, c = _to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
_validate_ohlc_lengths(o, h, lo, c)
|
|
try:
|
|
return _cdlmarubozu(o, h, lo, c)
|
|
except ValueError as e:
|
|
_normalize_rust_error(e)
|
|
|
|
|
|
def CDLSPINNINGTOP(
|
|
open: ArrayLike,
|
|
high: ArrayLike,
|
|
low: ArrayLike,
|
|
close: ArrayLike,
|
|
) -> np.ndarray:
|
|
"""Spinning Top — small body with shadows longer than the body.
|
|
|
|
Parameters
|
|
----------
|
|
open, high, low, close : array-like
|
|
OHLC price arrays.
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray[int32]
|
|
100 (bullish), -100 (bearish), or 0.
|
|
"""
|
|
o, h, lo, c = _to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
_validate_ohlc_lengths(o, h, lo, c)
|
|
try:
|
|
return _cdlspinningtop(
|
|
_to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
)
|
|
except ValueError as e:
|
|
_normalize_rust_error(e)
|
|
|
|
|
|
def CDL3BLACKCROWS(
|
|
open: ArrayLike,
|
|
high: ArrayLike,
|
|
low: ArrayLike,
|
|
close: ArrayLike,
|
|
) -> np.ndarray:
|
|
"""Three Black Crows — bearish 3-candle reversal.
|
|
|
|
Three consecutive long bearish candles, each opening within the prior body
|
|
and closing near its low.
|
|
|
|
Parameters
|
|
----------
|
|
open, high, low, close : array-like
|
|
OHLC price arrays.
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray[int32]
|
|
-100 where pattern is detected, 0 otherwise.
|
|
"""
|
|
o, h, lo, c = _to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
_validate_ohlc_lengths(o, h, lo, c)
|
|
try:
|
|
return _cdl3blackcrows(
|
|
_to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
)
|
|
except ValueError as e:
|
|
_normalize_rust_error(e)
|
|
|
|
|
|
def CDL3WHITESOLDIERS(
|
|
open: ArrayLike,
|
|
high: ArrayLike,
|
|
low: ArrayLike,
|
|
close: ArrayLike,
|
|
) -> np.ndarray:
|
|
"""Three White Soldiers — bullish 3-candle reversal.
|
|
|
|
Three consecutive long bullish candles, each opening within the prior body
|
|
and closing near its high.
|
|
|
|
Parameters
|
|
----------
|
|
open, high, low, close : array-like
|
|
OHLC price arrays.
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray[int32]
|
|
100 where pattern is detected, 0 otherwise.
|
|
"""
|
|
o, h, lo, c = _to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
_validate_ohlc_lengths(o, h, lo, c)
|
|
try:
|
|
return _cdl3whitesoldiers(
|
|
_to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
)
|
|
except ValueError as e:
|
|
_normalize_rust_error(e)
|
|
|
|
|
|
def CDL3INSIDE(
|
|
open: ArrayLike,
|
|
high: ArrayLike,
|
|
low: ArrayLike,
|
|
close: ArrayLike,
|
|
) -> np.ndarray:
|
|
"""Three Inside Up/Down — harami followed by confirmation candle.
|
|
|
|
Parameters
|
|
----------
|
|
open, high, low, close : array-like
|
|
OHLC price arrays.
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray[int32]
|
|
100 (bullish Three Inside Up), -100 (bearish Three Inside Down), or 0.
|
|
"""
|
|
o, h, lo, c = _to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
_validate_ohlc_lengths(o, h, lo, c)
|
|
try:
|
|
return _cdl3inside(o, h, lo, c)
|
|
except ValueError as e:
|
|
_normalize_rust_error(e)
|
|
|
|
|
|
def CDL3OUTSIDE(
|
|
open: ArrayLike,
|
|
high: ArrayLike,
|
|
low: ArrayLike,
|
|
close: ArrayLike,
|
|
) -> np.ndarray:
|
|
"""Three Outside Up/Down — engulfing followed by confirmation candle.
|
|
|
|
Parameters
|
|
----------
|
|
open, high, low, close : array-like
|
|
OHLC price arrays.
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray[int32]
|
|
100 (bullish Three Outside Up), -100 (bearish Three Outside Down), or 0.
|
|
"""
|
|
o, h, lo, c = _to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
_validate_ohlc_lengths(o, h, lo, c)
|
|
try:
|
|
return _cdl3outside(o, h, lo, c)
|
|
except ValueError as e:
|
|
_normalize_rust_error(e)
|
|
|
|
|
|
def CDLDOJISTAR(
|
|
open: ArrayLike,
|
|
high: ArrayLike,
|
|
low: ArrayLike,
|
|
close: ArrayLike,
|
|
) -> np.ndarray:
|
|
"""Doji Star — doji that gaps away from the prior large candle.
|
|
|
|
Parameters
|
|
----------
|
|
open, high, low, close : array-like
|
|
OHLC price arrays.
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray[int32]
|
|
100 (bullish), -100 (bearish), or 0.
|
|
"""
|
|
o, h, lo, c = _to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
_validate_ohlc_lengths(o, h, lo, c)
|
|
try:
|
|
return _cdldojistar(o, h, lo, c)
|
|
except ValueError as e:
|
|
_normalize_rust_error(e)
|
|
|
|
|
|
def CDLMORNINGDOJISTAR(
|
|
open: ArrayLike,
|
|
high: ArrayLike,
|
|
low: ArrayLike,
|
|
close: ArrayLike,
|
|
) -> np.ndarray:
|
|
"""Morning Doji Star — 3-candle bullish reversal with doji star.
|
|
|
|
Parameters
|
|
----------
|
|
open, high, low, close : array-like
|
|
OHLC price arrays.
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray[int32]
|
|
100 where pattern is detected, 0 otherwise.
|
|
"""
|
|
o, h, lo, c = _to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
_validate_ohlc_lengths(o, h, lo, c)
|
|
try:
|
|
return _cdlmorningdojistar(
|
|
_to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
)
|
|
except ValueError as e:
|
|
_normalize_rust_error(e)
|
|
|
|
|
|
def CDLEVENINGDOJISTAR(
|
|
open: ArrayLike,
|
|
high: ArrayLike,
|
|
low: ArrayLike,
|
|
close: ArrayLike,
|
|
) -> np.ndarray:
|
|
"""Evening Doji Star — 3-candle bearish reversal with doji star.
|
|
|
|
Parameters
|
|
----------
|
|
open, high, low, close : array-like
|
|
OHLC price arrays.
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray[int32]
|
|
-100 where pattern is detected, 0 otherwise.
|
|
"""
|
|
o, h, lo, c = _to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
_validate_ohlc_lengths(o, h, lo, c)
|
|
try:
|
|
return _cdleveningdojistar(
|
|
_to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
)
|
|
except ValueError as e:
|
|
_normalize_rust_error(e)
|
|
|
|
|
|
def CDLHARAMI(
|
|
open: ArrayLike,
|
|
high: ArrayLike,
|
|
low: ArrayLike,
|
|
close: ArrayLike,
|
|
) -> np.ndarray:
|
|
"""Harami Pattern — small candle inside the prior large candle's body.
|
|
|
|
Parameters
|
|
----------
|
|
open, high, low, close : array-like
|
|
OHLC price arrays.
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray[int32]
|
|
100 (bullish), -100 (bearish), or 0.
|
|
"""
|
|
o, h, lo, c = _to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
_validate_ohlc_lengths(o, h, lo, c)
|
|
try:
|
|
return _cdlharami(o, h, lo, c)
|
|
except ValueError as e:
|
|
_normalize_rust_error(e)
|
|
|
|
|
|
def CDLHARAMICROSS(
|
|
open: ArrayLike,
|
|
high: ArrayLike,
|
|
low: ArrayLike,
|
|
close: ArrayLike,
|
|
) -> np.ndarray:
|
|
"""Harami Cross — doji inside the prior large candle's body.
|
|
|
|
Parameters
|
|
----------
|
|
open, high, low, close : array-like
|
|
OHLC price arrays.
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray[int32]
|
|
100 (bullish), -100 (bearish), or 0.
|
|
"""
|
|
o, h, lo, c = _to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
_validate_ohlc_lengths(o, h, lo, c)
|
|
try:
|
|
return _cdlharamicross(
|
|
_to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
)
|
|
except ValueError as e:
|
|
_normalize_rust_error(e)
|
|
|
|
|
|
def CDL3LINESTRIKE(
|
|
open: ArrayLike,
|
|
high: ArrayLike,
|
|
low: ArrayLike,
|
|
close: ArrayLike,
|
|
) -> np.ndarray:
|
|
"""Three-Line Strike — 4-candle reversal pattern.
|
|
|
|
Parameters
|
|
----------
|
|
open, high, low, close : array-like
|
|
OHLC price arrays.
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray[int32]
|
|
100 (bullish), -100 (bearish), or 0.
|
|
"""
|
|
o, h, lo, c = _to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
_validate_ohlc_lengths(o, h, lo, c)
|
|
try:
|
|
return _cdl3linestrike(
|
|
_to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
)
|
|
except ValueError as e:
|
|
_normalize_rust_error(e)
|
|
|
|
|
|
def CDL3STARSINSOUTH(
|
|
open: ArrayLike,
|
|
high: ArrayLike,
|
|
low: ArrayLike,
|
|
close: ArrayLike,
|
|
) -> np.ndarray:
|
|
"""Three Stars In The South — 3-candle bullish reversal.
|
|
|
|
Parameters
|
|
----------
|
|
open, high, low, close : array-like
|
|
OHLC price arrays.
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray[int32]
|
|
100 where pattern is detected, 0 otherwise.
|
|
"""
|
|
o, h, lo, c = _to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
_validate_ohlc_lengths(o, h, lo, c)
|
|
try:
|
|
return _cdl3starsinsouth(
|
|
_to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
)
|
|
except ValueError as e:
|
|
_normalize_rust_error(e)
|
|
|
|
|
|
def CDLABANDONEDBABY(
|
|
open: ArrayLike,
|
|
high: ArrayLike,
|
|
low: ArrayLike,
|
|
close: ArrayLike,
|
|
) -> np.ndarray:
|
|
"""Abandoned Baby — 3-candle reversal with gapping doji in the middle.
|
|
|
|
Parameters
|
|
----------
|
|
open, high, low, close : array-like
|
|
OHLC price arrays.
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray[int32]
|
|
100 (bullish), -100 (bearish), or 0.
|
|
"""
|
|
o, h, lo, c = _to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
_validate_ohlc_lengths(o, h, lo, c)
|
|
try:
|
|
return _cdlabandonedbaby(
|
|
_to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
)
|
|
except ValueError as e:
|
|
_normalize_rust_error(e)
|
|
|
|
|
|
def CDLADVANCEBLOCK(
|
|
open: ArrayLike,
|
|
high: ArrayLike,
|
|
low: ArrayLike,
|
|
close: ArrayLike,
|
|
) -> np.ndarray:
|
|
"""Advance Block — 3 bullish candles with weakening momentum, bearish warning.
|
|
|
|
Parameters
|
|
----------
|
|
open, high, low, close : array-like
|
|
OHLC price arrays.
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray[int32]
|
|
-100 where pattern is detected, 0 otherwise.
|
|
"""
|
|
o, h, lo, c = _to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
_validate_ohlc_lengths(o, h, lo, c)
|
|
try:
|
|
return _cdladvanceblock(
|
|
_to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
)
|
|
except ValueError as e:
|
|
_normalize_rust_error(e)
|
|
|
|
|
|
def CDLBELTHOLD(
|
|
open: ArrayLike,
|
|
high: ArrayLike,
|
|
low: ArrayLike,
|
|
close: ArrayLike,
|
|
) -> np.ndarray:
|
|
"""Belt-hold — single candle opening at extreme with long body.
|
|
|
|
Parameters
|
|
----------
|
|
open, high, low, close : array-like
|
|
OHLC price arrays.
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray[int32]
|
|
100 (bullish), -100 (bearish), or 0.
|
|
"""
|
|
o, h, lo, c = _to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
_validate_ohlc_lengths(o, h, lo, c)
|
|
try:
|
|
return _cdlbelthold(o, h, lo, c)
|
|
except ValueError as e:
|
|
_normalize_rust_error(e)
|
|
|
|
|
|
def CDLBREAKAWAY(
|
|
open: ArrayLike,
|
|
high: ArrayLike,
|
|
low: ArrayLike,
|
|
close: ArrayLike,
|
|
) -> np.ndarray:
|
|
"""Breakaway — 5-candle reversal pattern.
|
|
|
|
Parameters
|
|
----------
|
|
open, high, low, close : array-like
|
|
OHLC price arrays.
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray[int32]
|
|
100 (bullish), -100 (bearish), or 0.
|
|
"""
|
|
o, h, lo, c = _to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
_validate_ohlc_lengths(o, h, lo, c)
|
|
try:
|
|
return _cdlbreakaway(o, h, lo, c)
|
|
except ValueError as e:
|
|
_normalize_rust_error(e)
|
|
|
|
|
|
def CDLCLOSINGMARUBOZU(
|
|
open: ArrayLike,
|
|
high: ArrayLike,
|
|
low: ArrayLike,
|
|
close: ArrayLike,
|
|
) -> np.ndarray:
|
|
"""Closing Marubozu — candle with no shadow on the closing side.
|
|
|
|
Parameters
|
|
----------
|
|
open, high, low, close : array-like
|
|
OHLC price arrays.
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray[int32]
|
|
100 (bullish), -100 (bearish), or 0.
|
|
"""
|
|
o, h, lo, c = _to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
_validate_ohlc_lengths(o, h, lo, c)
|
|
try:
|
|
return _cdlclosingmarubozu(
|
|
_to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
)
|
|
except ValueError as e:
|
|
_normalize_rust_error(e)
|
|
|
|
|
|
def CDLCONCEALBABYSWALL(
|
|
open: ArrayLike,
|
|
high: ArrayLike,
|
|
low: ArrayLike,
|
|
close: ArrayLike,
|
|
) -> np.ndarray:
|
|
"""Concealing Baby Swallow — 4-candle bullish reversal.
|
|
|
|
Parameters
|
|
----------
|
|
open, high, low, close : array-like
|
|
OHLC price arrays.
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray[int32]
|
|
100 where pattern is detected, 0 otherwise.
|
|
"""
|
|
o, h, lo, c = _to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
_validate_ohlc_lengths(o, h, lo, c)
|
|
try:
|
|
return _cdlconcealbabyswall(
|
|
_to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
)
|
|
except ValueError as e:
|
|
_normalize_rust_error(e)
|
|
|
|
|
|
def CDLCOUNTERATTACK(
|
|
open: ArrayLike,
|
|
high: ArrayLike,
|
|
low: ArrayLike,
|
|
close: ArrayLike,
|
|
) -> np.ndarray:
|
|
"""Counterattack Lines — 2-candle pattern with opposite candles closing at same price.
|
|
|
|
Parameters
|
|
----------
|
|
open, high, low, close : array-like
|
|
OHLC price arrays.
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray[int32]
|
|
100 (bullish), -100 (bearish), or 0.
|
|
"""
|
|
o, h, lo, c = _to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
_validate_ohlc_lengths(o, h, lo, c)
|
|
try:
|
|
return _cdlcounterattack(
|
|
_to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
)
|
|
except ValueError as e:
|
|
_normalize_rust_error(e)
|
|
|
|
|
|
def CDLDARKCLOUDCOVER(
|
|
open: ArrayLike,
|
|
high: ArrayLike,
|
|
low: ArrayLike,
|
|
close: ArrayLike,
|
|
) -> np.ndarray:
|
|
"""Dark Cloud Cover — 2-candle bearish reversal.
|
|
|
|
Parameters
|
|
----------
|
|
open, high, low, close : array-like
|
|
OHLC price arrays.
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray[int32]
|
|
-100 where pattern is detected, 0 otherwise.
|
|
"""
|
|
o, h, lo, c = _to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
_validate_ohlc_lengths(o, h, lo, c)
|
|
try:
|
|
return _cdldarkcloudcover(
|
|
_to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
)
|
|
except ValueError as e:
|
|
_normalize_rust_error(e)
|
|
|
|
|
|
def CDLDRAGONFLYDOJI(
|
|
open: ArrayLike,
|
|
high: ArrayLike,
|
|
low: ArrayLike,
|
|
close: ArrayLike,
|
|
) -> np.ndarray:
|
|
"""Dragonfly Doji — doji with long lower shadow.
|
|
|
|
Parameters
|
|
----------
|
|
open, high, low, close : array-like
|
|
OHLC price arrays.
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray[int32]
|
|
100 where pattern is detected, 0 otherwise.
|
|
"""
|
|
o, h, lo, c = _to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
_validate_ohlc_lengths(o, h, lo, c)
|
|
try:
|
|
return _cdldragonflydoji(
|
|
_to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
)
|
|
except ValueError as e:
|
|
_normalize_rust_error(e)
|
|
|
|
|
|
def CDLGAPSIDESIDEWHITE(
|
|
open: ArrayLike,
|
|
high: ArrayLike,
|
|
low: ArrayLike,
|
|
close: ArrayLike,
|
|
) -> np.ndarray:
|
|
"""Up/Down-Gap Side-by-Side White Lines — 3-candle continuation.
|
|
|
|
Parameters
|
|
----------
|
|
open, high, low, close : array-like
|
|
OHLC price arrays.
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray[int32]
|
|
100 (upside gap), -100 (downside gap), or 0.
|
|
"""
|
|
o, h, lo, c = _to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
_validate_ohlc_lengths(o, h, lo, c)
|
|
try:
|
|
return _cdlgapsidesidewhite(
|
|
_to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
)
|
|
except ValueError as e:
|
|
_normalize_rust_error(e)
|
|
|
|
|
|
def CDLGRAVESTONEDOJI(
|
|
open: ArrayLike,
|
|
high: ArrayLike,
|
|
low: ArrayLike,
|
|
close: ArrayLike,
|
|
) -> np.ndarray:
|
|
"""Gravestone Doji — doji with long upper shadow.
|
|
|
|
Parameters
|
|
----------
|
|
open, high, low, close : array-like
|
|
OHLC price arrays.
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray[int32]
|
|
-100 where pattern is detected, 0 otherwise.
|
|
"""
|
|
o, h, lo, c = _to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
_validate_ohlc_lengths(o, h, lo, c)
|
|
try:
|
|
return _cdlgravestonedoji(
|
|
_to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
)
|
|
except ValueError as e:
|
|
_normalize_rust_error(e)
|
|
|
|
|
|
def CDLHANGINGMAN(
|
|
open: ArrayLike,
|
|
high: ArrayLike,
|
|
low: ArrayLike,
|
|
close: ArrayLike,
|
|
) -> np.ndarray:
|
|
"""Hanging Man — same shape as hammer but bearish warning.
|
|
|
|
Parameters
|
|
----------
|
|
open, high, low, close : array-like
|
|
OHLC price arrays.
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray[int32]
|
|
-100 where pattern is detected, 0 otherwise.
|
|
"""
|
|
o, h, lo, c = _to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
_validate_ohlc_lengths(o, h, lo, c)
|
|
try:
|
|
return _cdlhangingman(
|
|
_to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
)
|
|
except ValueError as e:
|
|
_normalize_rust_error(e)
|
|
|
|
|
|
def CDLHIGHWAVE(
|
|
open: ArrayLike,
|
|
high: ArrayLike,
|
|
low: ArrayLike,
|
|
close: ArrayLike,
|
|
) -> np.ndarray:
|
|
"""High-Wave Candle — small body with very long upper and lower shadows.
|
|
|
|
Parameters
|
|
----------
|
|
open, high, low, close : array-like
|
|
OHLC price arrays.
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray[int32]
|
|
100 (bullish), -100 (bearish), or 0.
|
|
"""
|
|
o, h, lo, c = _to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
_validate_ohlc_lengths(o, h, lo, c)
|
|
try:
|
|
return _cdlhighwave(o, h, lo, c)
|
|
except ValueError as e:
|
|
_normalize_rust_error(e)
|
|
|
|
|
|
def CDLHIKKAKE(
|
|
open: ArrayLike,
|
|
high: ArrayLike,
|
|
low: ArrayLike,
|
|
close: ArrayLike,
|
|
) -> np.ndarray:
|
|
"""Hikkake Pattern — inside bar followed by false breakout then reversal.
|
|
|
|
Parameters
|
|
----------
|
|
open, high, low, close : array-like
|
|
OHLC price arrays.
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray[int32]
|
|
100 (bullish), -100 (bearish), or 0.
|
|
"""
|
|
o, h, lo, c = _to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
_validate_ohlc_lengths(o, h, lo, c)
|
|
try:
|
|
return _cdlhikkake(o, h, lo, c)
|
|
except ValueError as e:
|
|
_normalize_rust_error(e)
|
|
|
|
|
|
def CDLHIKKAKEMOD(
|
|
open: ArrayLike,
|
|
high: ArrayLike,
|
|
low: ArrayLike,
|
|
close: ArrayLike,
|
|
) -> np.ndarray:
|
|
"""Modified Hikkake Pattern — hikkake with delayed confirmation.
|
|
|
|
Parameters
|
|
----------
|
|
open, high, low, close : array-like
|
|
OHLC price arrays.
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray[int32]
|
|
100 (bullish), -100 (bearish), or 0.
|
|
"""
|
|
o, h, lo, c = _to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
_validate_ohlc_lengths(o, h, lo, c)
|
|
try:
|
|
return _cdlhikkakemod(
|
|
_to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
)
|
|
except ValueError as e:
|
|
_normalize_rust_error(e)
|
|
|
|
|
|
def CDLHOMINGPIGEON(
|
|
open: ArrayLike,
|
|
high: ArrayLike,
|
|
low: ArrayLike,
|
|
close: ArrayLike,
|
|
) -> np.ndarray:
|
|
"""Homing Pigeon — 2 bearish candles, second inside the first body.
|
|
|
|
Parameters
|
|
----------
|
|
open, high, low, close : array-like
|
|
OHLC price arrays.
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray[int32]
|
|
100 where pattern is detected, 0 otherwise.
|
|
"""
|
|
o, h, lo, c = _to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
_validate_ohlc_lengths(o, h, lo, c)
|
|
try:
|
|
return _cdlhomingpigeon(
|
|
_to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
)
|
|
except ValueError as e:
|
|
_normalize_rust_error(e)
|
|
|
|
|
|
def CDLIDENTICAL3CROWS(
|
|
open: ArrayLike,
|
|
high: ArrayLike,
|
|
low: ArrayLike,
|
|
close: ArrayLike,
|
|
) -> np.ndarray:
|
|
"""Identical Three Crows — 3 bearish candles each opening at prior close.
|
|
|
|
Parameters
|
|
----------
|
|
open, high, low, close : array-like
|
|
OHLC price arrays.
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray[int32]
|
|
-100 where pattern is detected, 0 otherwise.
|
|
"""
|
|
o, h, lo, c = _to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
_validate_ohlc_lengths(o, h, lo, c)
|
|
try:
|
|
return _cdlidentical3crows(
|
|
_to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
)
|
|
except ValueError as e:
|
|
_normalize_rust_error(e)
|
|
|
|
|
|
def CDLINNECK(
|
|
open: ArrayLike,
|
|
high: ArrayLike,
|
|
low: ArrayLike,
|
|
close: ArrayLike,
|
|
) -> np.ndarray:
|
|
"""In-Neck Pattern — bearish then bullish closing near prior close, bearish continuation.
|
|
|
|
Parameters
|
|
----------
|
|
open, high, low, close : array-like
|
|
OHLC price arrays.
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray[int32]
|
|
-100 where pattern is detected, 0 otherwise.
|
|
"""
|
|
o, h, lo, c = _to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
_validate_ohlc_lengths(o, h, lo, c)
|
|
try:
|
|
return _cdlinneck(o, h, lo, c)
|
|
except ValueError as e:
|
|
_normalize_rust_error(e)
|
|
|
|
|
|
def CDLINVERTEDHAMMER(
|
|
open: ArrayLike,
|
|
high: ArrayLike,
|
|
low: ArrayLike,
|
|
close: ArrayLike,
|
|
) -> np.ndarray:
|
|
"""Inverted Hammer — small body at bottom, long upper shadow.
|
|
|
|
Parameters
|
|
----------
|
|
open, high, low, close : array-like
|
|
OHLC price arrays.
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray[int32]
|
|
100 where pattern is detected, 0 otherwise.
|
|
"""
|
|
o, h, lo, c = _to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
_validate_ohlc_lengths(o, h, lo, c)
|
|
try:
|
|
return _cdlinvertedhammer(
|
|
_to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
)
|
|
except ValueError as e:
|
|
_normalize_rust_error(e)
|
|
|
|
|
|
def CDLKICKING(
|
|
open: ArrayLike,
|
|
high: ArrayLike,
|
|
low: ArrayLike,
|
|
close: ArrayLike,
|
|
) -> np.ndarray:
|
|
"""Kicking — two opposite marubozu candles with a gap.
|
|
|
|
Parameters
|
|
----------
|
|
open, high, low, close : array-like
|
|
OHLC price arrays.
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray[int32]
|
|
100 (bullish), -100 (bearish), or 0.
|
|
"""
|
|
o, h, lo, c = _to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
_validate_ohlc_lengths(o, h, lo, c)
|
|
try:
|
|
return _cdlkicking(o, h, lo, c)
|
|
except ValueError as e:
|
|
_normalize_rust_error(e)
|
|
|
|
|
|
def CDLKICKINGBYLENGTH(
|
|
open: ArrayLike,
|
|
high: ArrayLike,
|
|
low: ArrayLike,
|
|
close: ArrayLike,
|
|
) -> np.ndarray:
|
|
"""Kicking by the Longer Marubozu — direction determined by longer marubozu.
|
|
|
|
Parameters
|
|
----------
|
|
open, high, low, close : array-like
|
|
OHLC price arrays.
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray[int32]
|
|
100 (bullish), -100 (bearish), or 0.
|
|
"""
|
|
o, h, lo, c = _to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
_validate_ohlc_lengths(o, h, lo, c)
|
|
try:
|
|
return _cdlkickingbylength(
|
|
_to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
)
|
|
except ValueError as e:
|
|
_normalize_rust_error(e)
|
|
|
|
|
|
def CDLLADDERBOTTOM(
|
|
open: ArrayLike,
|
|
high: ArrayLike,
|
|
low: ArrayLike,
|
|
close: ArrayLike,
|
|
) -> np.ndarray:
|
|
"""Ladder Bottom — 5-candle bullish reversal.
|
|
|
|
Parameters
|
|
----------
|
|
open, high, low, close : array-like
|
|
OHLC price arrays.
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray[int32]
|
|
100 where pattern is detected, 0 otherwise.
|
|
"""
|
|
o, h, lo, c = _to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
_validate_ohlc_lengths(o, h, lo, c)
|
|
try:
|
|
return _cdlladderbottom(
|
|
_to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
)
|
|
except ValueError as e:
|
|
_normalize_rust_error(e)
|
|
|
|
|
|
def CDLLONGLEGGEDDOJI(
|
|
open: ArrayLike,
|
|
high: ArrayLike,
|
|
low: ArrayLike,
|
|
close: ArrayLike,
|
|
) -> np.ndarray:
|
|
"""Long Legged Doji — doji with long upper and lower shadows.
|
|
|
|
Parameters
|
|
----------
|
|
open, high, low, close : array-like
|
|
OHLC price arrays.
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray[int32]
|
|
100 where pattern is detected, 0 otherwise.
|
|
"""
|
|
o, h, lo, c = _to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
_validate_ohlc_lengths(o, h, lo, c)
|
|
try:
|
|
return _cdllongleggeddoji(
|
|
_to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
)
|
|
except ValueError as e:
|
|
_normalize_rust_error(e)
|
|
|
|
|
|
def CDLLONGLINE(
|
|
open: ArrayLike,
|
|
high: ArrayLike,
|
|
low: ArrayLike,
|
|
close: ArrayLike,
|
|
) -> np.ndarray:
|
|
"""Long Line Candle — long body candle (body >= 70% of range).
|
|
|
|
Parameters
|
|
----------
|
|
open, high, low, close : array-like
|
|
OHLC price arrays.
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray[int32]
|
|
100 (bullish), -100 (bearish), or 0.
|
|
"""
|
|
o, h, lo, c = _to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
_validate_ohlc_lengths(o, h, lo, c)
|
|
try:
|
|
return _cdllongline(o, h, lo, c)
|
|
except ValueError as e:
|
|
_normalize_rust_error(e)
|
|
|
|
|
|
def CDLMATCHINGLOW(
|
|
open: ArrayLike,
|
|
high: ArrayLike,
|
|
low: ArrayLike,
|
|
close: ArrayLike,
|
|
) -> np.ndarray:
|
|
"""Matching Low — 2 bearish candles with equal closes, bullish reversal.
|
|
|
|
Parameters
|
|
----------
|
|
open, high, low, close : array-like
|
|
OHLC price arrays.
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray[int32]
|
|
100 where pattern is detected, 0 otherwise.
|
|
"""
|
|
o, h, lo, c = _to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
_validate_ohlc_lengths(o, h, lo, c)
|
|
try:
|
|
return _cdlmatchinglow(
|
|
_to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
)
|
|
except ValueError as e:
|
|
_normalize_rust_error(e)
|
|
|
|
|
|
def CDLMATHOLD(
|
|
open: ArrayLike,
|
|
high: ArrayLike,
|
|
low: ArrayLike,
|
|
close: ArrayLike,
|
|
) -> np.ndarray:
|
|
"""Mat Hold — 5-candle bullish continuation pattern.
|
|
|
|
Parameters
|
|
----------
|
|
open, high, low, close : array-like
|
|
OHLC price arrays.
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray[int32]
|
|
100 where pattern is detected, 0 otherwise.
|
|
"""
|
|
o, h, lo, c = _to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
_validate_ohlc_lengths(o, h, lo, c)
|
|
try:
|
|
return _cdlmathold(o, h, lo, c)
|
|
except ValueError as e:
|
|
_normalize_rust_error(e)
|
|
|
|
|
|
def CDLONNECK(
|
|
open: ArrayLike,
|
|
high: ArrayLike,
|
|
low: ArrayLike,
|
|
close: ArrayLike,
|
|
) -> np.ndarray:
|
|
"""On-Neck Pattern — bearish then bullish reaching only prior low, bearish continuation.
|
|
|
|
Parameters
|
|
----------
|
|
open, high, low, close : array-like
|
|
OHLC price arrays.
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray[int32]
|
|
-100 where pattern is detected, 0 otherwise.
|
|
"""
|
|
o, h, lo, c = _to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
_validate_ohlc_lengths(o, h, lo, c)
|
|
try:
|
|
return _cdlonneck(o, h, lo, c)
|
|
except ValueError as e:
|
|
_normalize_rust_error(e)
|
|
|
|
|
|
def CDLPIERCING(
|
|
open: ArrayLike,
|
|
high: ArrayLike,
|
|
low: ArrayLike,
|
|
close: ArrayLike,
|
|
) -> np.ndarray:
|
|
"""Piercing Pattern — bearish then bullish piercing past midpoint, bullish reversal.
|
|
|
|
Parameters
|
|
----------
|
|
open, high, low, close : array-like
|
|
OHLC price arrays.
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray[int32]
|
|
100 where pattern is detected, 0 otherwise.
|
|
"""
|
|
o, h, lo, c = _to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
_validate_ohlc_lengths(o, h, lo, c)
|
|
try:
|
|
return _cdlpiercing(o, h, lo, c)
|
|
except ValueError as e:
|
|
_normalize_rust_error(e)
|
|
|
|
|
|
def CDLRICKSHAWMAN(
|
|
open: ArrayLike,
|
|
high: ArrayLike,
|
|
low: ArrayLike,
|
|
close: ArrayLike,
|
|
) -> np.ndarray:
|
|
"""Rickshaw Man — doji with long shadows and body near center.
|
|
|
|
Parameters
|
|
----------
|
|
open, high, low, close : array-like
|
|
OHLC price arrays.
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray[int32]
|
|
100 where pattern is detected, 0 otherwise.
|
|
"""
|
|
o, h, lo, c = _to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
_validate_ohlc_lengths(o, h, lo, c)
|
|
try:
|
|
return _cdlrickshawman(
|
|
_to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
)
|
|
except ValueError as e:
|
|
_normalize_rust_error(e)
|
|
|
|
|
|
def CDLRISEFALL3METHODS(
|
|
open: ArrayLike,
|
|
high: ArrayLike,
|
|
low: ArrayLike,
|
|
close: ArrayLike,
|
|
) -> np.ndarray:
|
|
"""Rising/Falling Three Methods — 5-candle continuation pattern.
|
|
|
|
Parameters
|
|
----------
|
|
open, high, low, close : array-like
|
|
OHLC price arrays.
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray[int32]
|
|
100 (bullish), -100 (bearish), or 0.
|
|
"""
|
|
o, h, lo, c = _to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
_validate_ohlc_lengths(o, h, lo, c)
|
|
try:
|
|
return _cdlrisefall3methods(
|
|
_to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
)
|
|
except ValueError as e:
|
|
_normalize_rust_error(e)
|
|
|
|
|
|
def CDLSEPARATINGLINES(
|
|
open: ArrayLike,
|
|
high: ArrayLike,
|
|
low: ArrayLike,
|
|
close: ArrayLike,
|
|
) -> np.ndarray:
|
|
"""Separating Lines — 2-candle continuation with same open, opposite direction.
|
|
|
|
Parameters
|
|
----------
|
|
open, high, low, close : array-like
|
|
OHLC price arrays.
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray[int32]
|
|
100 (bullish), -100 (bearish), or 0.
|
|
"""
|
|
o, h, lo, c = _to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
_validate_ohlc_lengths(o, h, lo, c)
|
|
try:
|
|
return _cdlseparatinglines(
|
|
_to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
)
|
|
except ValueError as e:
|
|
_normalize_rust_error(e)
|
|
|
|
|
|
def CDLSHORTLINE(
|
|
open: ArrayLike,
|
|
high: ArrayLike,
|
|
low: ArrayLike,
|
|
close: ArrayLike,
|
|
) -> np.ndarray:
|
|
"""Short Line Candle — small body (body <= 30% of range).
|
|
|
|
Parameters
|
|
----------
|
|
open, high, low, close : array-like
|
|
OHLC price arrays.
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray[int32]
|
|
100 (bullish), -100 (bearish), or 0.
|
|
"""
|
|
o, h, lo, c = _to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
_validate_ohlc_lengths(o, h, lo, c)
|
|
try:
|
|
return _cdlshortline(o, h, lo, c)
|
|
except ValueError as e:
|
|
_normalize_rust_error(e)
|
|
|
|
|
|
def CDLSTALLEDPATTERN(
|
|
open: ArrayLike,
|
|
high: ArrayLike,
|
|
low: ArrayLike,
|
|
close: ArrayLike,
|
|
) -> np.ndarray:
|
|
"""Stalled Pattern — 3 bullish candles with stalling on the third, bearish warning.
|
|
|
|
Parameters
|
|
----------
|
|
open, high, low, close : array-like
|
|
OHLC price arrays.
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray[int32]
|
|
-100 where pattern is detected, 0 otherwise.
|
|
"""
|
|
o, h, lo, c = _to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
_validate_ohlc_lengths(o, h, lo, c)
|
|
try:
|
|
return _cdlstalledpattern(
|
|
_to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
)
|
|
except ValueError as e:
|
|
_normalize_rust_error(e)
|
|
|
|
|
|
def CDLSTICKSANDWICH(
|
|
open: ArrayLike,
|
|
high: ArrayLike,
|
|
low: ArrayLike,
|
|
close: ArrayLike,
|
|
) -> np.ndarray:
|
|
"""Stick Sandwich — 2 bearish candles surrounding a bullish, same close.
|
|
|
|
Parameters
|
|
----------
|
|
open, high, low, close : array-like
|
|
OHLC price arrays.
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray[int32]
|
|
100 where pattern is detected, 0 otherwise.
|
|
"""
|
|
o, h, lo, c = _to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
_validate_ohlc_lengths(o, h, lo, c)
|
|
try:
|
|
return _cdlsticksandwich(
|
|
_to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
)
|
|
except ValueError as e:
|
|
_normalize_rust_error(e)
|
|
|
|
|
|
def CDLTAKURI(
|
|
open: ArrayLike,
|
|
high: ArrayLike,
|
|
low: ArrayLike,
|
|
close: ArrayLike,
|
|
) -> np.ndarray:
|
|
"""Takuri — Dragonfly Doji with very long lower shadow (>= 3x body).
|
|
|
|
Parameters
|
|
----------
|
|
open, high, low, close : array-like
|
|
OHLC price arrays.
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray[int32]
|
|
100 where pattern is detected, 0 otherwise.
|
|
"""
|
|
o, h, lo, c = _to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
_validate_ohlc_lengths(o, h, lo, c)
|
|
try:
|
|
return _cdltakuri(o, h, lo, c)
|
|
except ValueError as e:
|
|
_normalize_rust_error(e)
|
|
|
|
|
|
def CDLTASUKIGAP(
|
|
open: ArrayLike,
|
|
high: ArrayLike,
|
|
low: ArrayLike,
|
|
close: ArrayLike,
|
|
) -> np.ndarray:
|
|
"""Tasuki Gap — 3-candle gap continuation with partial fill.
|
|
|
|
Parameters
|
|
----------
|
|
open, high, low, close : array-like
|
|
OHLC price arrays.
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray[int32]
|
|
100 (bullish), -100 (bearish), or 0.
|
|
"""
|
|
o, h, lo, c = _to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
_validate_ohlc_lengths(o, h, lo, c)
|
|
try:
|
|
return _cdltasukigap(o, h, lo, c)
|
|
except ValueError as e:
|
|
_normalize_rust_error(e)
|
|
|
|
|
|
def CDLTHRUSTING(
|
|
open: ArrayLike,
|
|
high: ArrayLike,
|
|
low: ArrayLike,
|
|
close: ArrayLike,
|
|
) -> np.ndarray:
|
|
"""Thrusting Pattern — bearish then bullish reaching below midpoint, bearish continuation.
|
|
|
|
Parameters
|
|
----------
|
|
open, high, low, close : array-like
|
|
OHLC price arrays.
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray[int32]
|
|
-100 where pattern is detected, 0 otherwise.
|
|
"""
|
|
o, h, lo, c = _to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
_validate_ohlc_lengths(o, h, lo, c)
|
|
try:
|
|
return _cdlthrusting(o, h, lo, c)
|
|
except ValueError as e:
|
|
_normalize_rust_error(e)
|
|
|
|
|
|
def CDLTRISTAR(
|
|
open: ArrayLike,
|
|
high: ArrayLike,
|
|
low: ArrayLike,
|
|
close: ArrayLike,
|
|
) -> np.ndarray:
|
|
"""Tristar Pattern — 3 dojis with reversal implication.
|
|
|
|
Parameters
|
|
----------
|
|
open, high, low, close : array-like
|
|
OHLC price arrays.
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray[int32]
|
|
100 (bullish), -100 (bearish), or 0.
|
|
"""
|
|
o, h, lo, c = _to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
_validate_ohlc_lengths(o, h, lo, c)
|
|
try:
|
|
return _cdltristar(o, h, lo, c)
|
|
except ValueError as e:
|
|
_normalize_rust_error(e)
|
|
|
|
|
|
def CDLUNIQUE3RIVER(
|
|
open: ArrayLike,
|
|
high: ArrayLike,
|
|
low: ArrayLike,
|
|
close: ArrayLike,
|
|
) -> np.ndarray:
|
|
"""Unique 3 River — 3-candle bullish reversal.
|
|
|
|
Parameters
|
|
----------
|
|
open, high, low, close : array-like
|
|
OHLC price arrays.
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray[int32]
|
|
100 where pattern is detected, 0 otherwise.
|
|
"""
|
|
o, h, lo, c = _to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
_validate_ohlc_lengths(o, h, lo, c)
|
|
try:
|
|
return _cdlunique3river(
|
|
_to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
)
|
|
except ValueError as e:
|
|
_normalize_rust_error(e)
|
|
|
|
|
|
def CDLUPSIDEGAP2CROWS(
|
|
open: ArrayLike,
|
|
high: ArrayLike,
|
|
low: ArrayLike,
|
|
close: ArrayLike,
|
|
) -> np.ndarray:
|
|
"""Upside Gap Two Crows — 3-candle bearish reversal.
|
|
|
|
Parameters
|
|
----------
|
|
open, high, low, close : array-like
|
|
OHLC price arrays.
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray[int32]
|
|
-100 where pattern is detected, 0 otherwise.
|
|
"""
|
|
o, h, lo, c = _to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
_validate_ohlc_lengths(o, h, lo, c)
|
|
try:
|
|
return _cdlupsidegap2crows(
|
|
_to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
)
|
|
except ValueError as e:
|
|
_normalize_rust_error(e)
|
|
|
|
|
|
def CDLXSIDEGAP3METHODS(
|
|
open: ArrayLike,
|
|
high: ArrayLike,
|
|
low: ArrayLike,
|
|
close: ArrayLike,
|
|
) -> np.ndarray:
|
|
"""Upside/Downside Gap Three Methods — 3-candle gap fill continuation.
|
|
|
|
Parameters
|
|
----------
|
|
open, high, low, close : array-like
|
|
OHLC price arrays.
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray[int32]
|
|
100 (bullish), -100 (bearish), or 0.
|
|
"""
|
|
o, h, lo, c = _to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
_validate_ohlc_lengths(o, h, lo, c)
|
|
try:
|
|
return _cdlxsidegap3methods(
|
|
_to_f64(open), _to_f64(high), _to_f64(low), _to_f64(close)
|
|
)
|
|
except ValueError as e:
|
|
_normalize_rust_error(e)
|
|
|
|
|
|
__all__ = [
|
|
"CDL2CROWS",
|
|
"CDL3BLACKCROWS",
|
|
"CDL3INSIDE",
|
|
"CDL3LINESTRIKE",
|
|
"CDL3OUTSIDE",
|
|
"CDL3STARSINSOUTH",
|
|
"CDL3WHITESOLDIERS",
|
|
"CDLABANDONEDBABY",
|
|
"CDLADVANCEBLOCK",
|
|
"CDLBELTHOLD",
|
|
"CDLBREAKAWAY",
|
|
"CDLCLOSINGMARUBOZU",
|
|
"CDLCONCEALBABYSWALL",
|
|
"CDLCOUNTERATTACK",
|
|
"CDLDARKCLOUDCOVER",
|
|
"CDLDOJI",
|
|
"CDLDOJISTAR",
|
|
"CDLDRAGONFLYDOJI",
|
|
"CDLENGULFING",
|
|
"CDLEVENINGDOJISTAR",
|
|
"CDLEVENINGSTAR",
|
|
"CDLGAPSIDESIDEWHITE",
|
|
"CDLGRAVESTONEDOJI",
|
|
"CDLHAMMER",
|
|
"CDLHANGINGMAN",
|
|
"CDLHARAMI",
|
|
"CDLHARAMICROSS",
|
|
"CDLHIGHWAVE",
|
|
"CDLHIKKAKE",
|
|
"CDLHIKKAKEMOD",
|
|
"CDLHOMINGPIGEON",
|
|
"CDLIDENTICAL3CROWS",
|
|
"CDLINNECK",
|
|
"CDLINVERTEDHAMMER",
|
|
"CDLKICKING",
|
|
"CDLKICKINGBYLENGTH",
|
|
"CDLLADDERBOTTOM",
|
|
"CDLLONGLEGGEDDOJI",
|
|
"CDLLONGLINE",
|
|
"CDLMARUBOZU",
|
|
"CDLMATCHINGLOW",
|
|
"CDLMATHOLD",
|
|
"CDLMORNINGDOJISTAR",
|
|
"CDLMORNINGSTAR",
|
|
"CDLONNECK",
|
|
"CDLPIERCING",
|
|
"CDLRICKSHAWMAN",
|
|
"CDLRISEFALL3METHODS",
|
|
"CDLSEPARATINGLINES",
|
|
"CDLSHOOTINGSTAR",
|
|
"CDLSHORTLINE",
|
|
"CDLSPINNINGTOP",
|
|
"CDLSTALLEDPATTERN",
|
|
"CDLSTICKSANDWICH",
|
|
"CDLTAKURI",
|
|
"CDLTASUKIGAP",
|
|
"CDLTHRUSTING",
|
|
"CDLTRISTAR",
|
|
"CDLUNIQUE3RIVER",
|
|
"CDLUPSIDEGAP2CROWS",
|
|
"CDLXSIDEGAP3METHODS",
|
|
]
|