If you have ever attempted to build an algorithmic trading bot in Python, you have almost certainly walked this exact path:
TA-Lib (after wrestling with C compilers, missing headers, and broken Windows wheels for an hour).
Why? Because in institutional quantitative finance, naked candlestick patterns are treated as little more than random noise.
A "Hammer" appearing in the middle of a low-volume consolidation against a cascading 200 EMA downtrend has almost zero statistical edge. But that same Hammer forming at the 200 EMA support, accompanied by a 2.5x Relative Volume (RVOL) spike and an oversold RSI (14) rebound, represents an institutional accumulation footprint.
Today, I’m open-sourcing yfinance-ta-patterns — an institutional-grade Python framework and CLI designed to bridge the gap between classic technical analysis, quantitative confluence modeling, and modern LLM-driven market intelligence.
yfinance-ta-patterns
pip or uv without needing C compilers or TA-Lib binaries.Open[i+1]), accounting for slippage, trading fees, FX currency conversion, and periodic Sharpe ratios.
[Raw Multi-Asset Data (yfinance)]
Stocks | Crypto | Forex | Commodities
│
▼
┌───────────────────────────┐
│ Candle Normalizer & QA │ ── Zero-lookahead, UTC 4h resample
└───────────────────────────┘
│
▼
┌───────────────────────────┐
│ Pattern Recognition Engine│ ── 61 TA-Lib Patterns + Pure NumPy Engine
└───────────────────────────┘
│
▼
┌───────────────────────────┐
│ AI Confluence Scorer │ ── EMA 20/50/200 + RVOL + RSI + ATR
└───────────────────────────┘
│
┌──────────────┴──────────────┐
▼ ▼
┌──────────────────┐ ┌───────────────────────┐
│ Algorithmic Setups│ │ AI Agent Markdown │
│ Entry, SL, TP1/2 │ │ Briefs & JSON Schema │
└──────────────────┘ └───────────────────────┘
Traditional libraries treat a candlestick pattern as a binary boolean: pattern detected: True/False.
In yfinance-ta-patterns, detecting a pattern is merely step one. The signal is then routed into the AIPatternScorer, which computes a multi-dimensional quantitative confluence score based on four objective market factors:
The engine verifies alignment across three exponential moving averages:
Bullish patterns receive maximum scoring when price action trades above an ascending 200 EMA with confirmed 20/50 bullish alignment.
Institutional accumulation leaves volume footprints. The scorer computes zero-lookahead Relative Volume ($RVOL = \frac{Volume_t}{SMA(Volume, 20)}$). Patterns accompanied by $RVOL > 1.8x$ receive significant scoring weight, filtering out low-liquidity false breaks.
Using J. Welles Wilder's exact smoothing algorithm, the engine measures whether the reversal pattern occurs at momentum extremes (oversold $< 35$ for bullish reversals, overbought $> 65$ for bearish reversals) or exhibits momentum divergence.
Evaluates whether the pattern candle body is dominant relative to recent Average True Range (filtering out doji indecision candles where decisive expansion was required).
yfinance-ta-patterns installs out-of-the-box with pure-Python fallbacks:
pip install yfinance-ta-patterns
Or with uv:
uv add yfinance-ta-patterns
(Optional: Native TA-Lib acceleration can be installed via pip install "yfinance-ta-patterns[talib]" or using pre-built wheels).
Here is how you scan multi-asset pairs, detect patterns, score confluence, and print an automated trade setup in just a few lines of code:
from yfinance_ta_patterns import MarketData, PatternAnalyzer
from yfinance_ta_patterns.ai.scorer import AIPatternScorer
= MarketData(symbol="NVDA", interval="1h", period="30d")
df = .get_data()
analyzer = PatternAnalyzer(df)
pattern_signals = analyzer.find_patterns(last_n_bars=3)
scorer = AIPatternScorer(df)
for signal in pattern_signals:
score = scorer.score_pattern(
pattern_name=signal["pattern"],
bar_idx=signal["index"],
signal_type=signal["direction"]
)
if score.confluence_score >= 0.70:
print(f"🔥 HIGH CONFLUENCE SETUP: {signal['pattern']} on {signal['timestamp']}")
print(f" Confluence Score: {score.confluence_score:.2f} / 1.00")
print(f" Trend Regime: {score.trend_alignment}")
print(f" Relative Volume: {score.rvol:.2f}x")
print(f" Wilder RSI (14): {score.rsi:.1f}")
setup = score.trade_setup
print(f" Entry: ${setup['entry']:.2f}")
print(f" Stop Loss: ${setup['stop_loss']:.2f} (ATR-based)")
print(f" Take Profit: ${setup['take_profit_1']:.2f} (1.5R)")
Modern trading architectures increasingly rely on LLM agents (Claude, GPT, Gemini, local Ollama models) for executive synthesis.
yfinance-ta-patterns includes an AI Market Analyst module that transforms technical data into structured briefs and JSON schemas:
from yfinance_ta_patterns.ai.analyst import AIMarketAnalyst
analyst = AIMarketAnalyst()
brief = analyst.generate_market_brief(df, pattern_signals, symbol="BTC-USD")
print(brief.markdown)
The output gives your LLM agent everything it needs — macroeconomic context, multi-timeframe trend status, pattern confluence, and risk parameters — without hallucinated indicators.
Prefer running from the terminal? yfinance-ta-patterns includes a lightning-fast CLI:
yftp --symbol NVDA --timeframe 1h --ai
yftp --symbol BTC-USD --all-patterns --timeframe 4h
uvx --from yfinance-ta-patterns yftp --symbol AAPL --timeframe 1d --ai
High-frequency market scanners often monitor hundreds of currency pairs or crypto tickers simultaneously.
yfinance-ta-patterns is designed for modern Python environments:
If you're interested in algorithmic trading, quantitative finance, or building AI trading agents, give yfinance-ta-patterns a try!
If you find the project useful, please consider dropping a Star ⭐ on GitHub — it helps the project grow and reach more developers!