polars-anta 0.3.0

ANTA (Alpha & Numerical Technical Analysis): Ultra-fast, zero-C-dependency technical analysis, market microstructure, and alpha factor library powered natively by Polars Expressions.

Documentation • Why polars-anta? • Architecture • Benchmarks • Installation • Quickstart • Indicator Catalog (175) • Development

Try it immediately in your browser: Run our 1-Minute Interactive Colab Demo with 1-click execution & live 112.4x speedup benchmarks!

Latest Highlights: Expanded to 175 native indicators, alpha factors & evaluation primitives - featuring 33 WorldQuant 101 Formulaic Alphas (alpha_001–alpha_030, alpha_041, alpha_054, alpha_101), an Alphalens-Style Factor Evaluation Suite (information_coefficient, ic_summary, quantile_analysis, factor_turnover), Strategy Performance Metrics (sharpe_ratio, sortino_ratio, calmar_ratio, max_drawdown, profit_factor), and a Lightweight Vectorized Backtester (df.anta.backtest()).

Why polars-anta?

Quantitative researchers and financial engineers have historically faced a trade-off between installation complexity, cross-sectional expressiveness, and execution speed:

polars-anta eliminates this compromise by implementing technical indicators, statistical regressions, and WorldQuant-style alpha factors directly as Polars Expressions (pl.Expr). Computations are pushed into Polars' multi-threaded Rust engine and vectorized sliding_window_view kernels, eliminating Python GIL bottlenecks without requiring any C compilers.

Architecture & Execution Pipeline

flowchart LR
    A["Raw Multi-Asset OHLCV<br/>(DataFrame / LazyFrame)"] --> B["1. Data Engineering<br/>validate_ohlcv() • resample()"]
    B --> C["2. Feature & Alpha Engine<br/>175 Native .anta Expressions<br/>(TA + WorldQuant Alphas)"]
    C --> D["3. Cross-Sectional Ops<br/>cs_winsorize → cs_zscore → neutralize"]
    D --> E["4. Factor Evaluation<br/>Rank IC • 5-Quantiles • Turnover"]
    E --> F["5. Vectorized Backtesting (v0.3.0)<br/>entries/exits • Fees • Tearsheet<br/>Dollar-Neutral / Long-Only"]

Core Architectural Pillars

• Dual Namespaces (.anta & .ta): Invoke any indicator via pl.col("close").anta.<indicator>() or the shorthand pl.col("close").ta.<indicator>() across Expressions, DataFrames, and LazyFrames.
• Fluent Pipeline Chaining: Chain data validation, timeframe resampling, and multi-indicator transformations directly on df.anta... or lf.anta..., or generate a complete quantitative feature suite in one call via df.anta.add_all(group_by="symbol").
• Closed-Form Algebraic Vectorization: Rolling OLS Linear Regression (slope, intercept, angle, forecast), CAPM rolling_beta/rolling_alpha, and heikin_ashi are rewritten in closed-form algebraic identities and native Polars ewm_mean recurrences—achieving 112.4x speedups over rolling Python/Pandas UDFs.
• Zero-Loop Stride-Tricks Kernels: Path-dependent rolling operators (ts_rank, percentile_rank, ts_argmax, ts_argmin, ts_product, hurst_exponent) use contiguous zero-copy numpy.lib.stride_tricks.sliding_window_view matrices instead of Python loops.
• Typed pl.Struct Outputs: Multi-line indicators (macd, bollinger_bands, keltner_channels, ichimoku, supertrend, heikin_ashi, squeeze_momentum) return strongly-typed pl.Struct expressions with unnest=True support on DataFrames/LazyFrames.
• Loop-Free Vectorized Backtester & State Machine (v0.3.0): Execute single-asset and multi-asset backtests directly in Polars with 1-line entries/exits triggers via .forward_fill() state propagation, .crosses_above()/.crosses_below() expressions, portfolio weight normalization (weight_scheme="dollar_neutral" / "long_only"), transaction fees, slippage, Buy & Hold benchmark tracking, and formatted tearsheets (bt.report(), pa.compare_strategies()).
• Alphalens-Style Factor Evaluation Suite (v0.3.0): Validate alpha predictability before committing capital via multi-horizon forward_returns(), Spearman Rank IC & ICIR summary (ic_summary()), quantile return monotonicity testing (quantile_analysis()), and signal rank autocorrelation (factor_turnover()).

Performance Benchmark (1,000,000 Rows)

Benchmarks measured across 1,000,000 bars (single-asset random walk) and a 500 tickers × 2,000 bars universe (1,000,000 rows). Computations executed on Polars' multi-threaded Rust query engine vs single-threaded Pandas:

Reproduce benchmarks locally using pip install -e ".[benchmark]" followed by python benchmarks/benchmark_speed.py.

Installation

Install directly from PyPI with zero C compiler requirements:

pip install polars-anta

Or using uv:

uv add polars-anta

Requirements: Python >= 3.10, Polars >= 1.0.0, NumPy >= 1.24.0

Quickstart & Quantitative Workflows

1. Fluent DataFrame & LazyFrame Chaining (.anta or .ta)

Validate raw OHLCV data, resample timeframes, transform candlesticks to Heikin-Ashi, and chain technical indicators on any pl.DataFrame or pl.LazyFrame:

import polars as pl
import polars_anta  # Registers .anta and .ta on Expressions, DataFrames, and LazyFrames

# End-to-end fluent pipeline on a multi-asset DataFrame or LazyFrame:
df_features = (
    df.anta.validate_ohlcv()
    .anta.resample("15m", group_by="symbol")
    .anta.heikin_ashi(unnest=True)
    .anta.sma(20)
    .anta.rsi(14)
    .anta.macd(unnest=True)
    .anta.bollinger_bands(period=20, unnest=True)
)

# Or generate a comprehensive quantitative feature suite in a single call:
df_all = df.anta.add_all(group_by="symbol")

2. Composable Expression Syntax (pl.col(...).anta or .ta)

Compose indicators directly inside .select() or .with_columns() alongside native Polars expressions:

import polars as pl
import polars_anta as pa

df = pl.DataFrame(
    {
        "open": [100.0, 101.5, 101.0, 102.5, 104.0, 103.5, 105.0],
        "high": [101.8, 103.0, 102.5, 104.2, 105.8, 105.0, 106.5],
        "low": [99.2, 100.8, 100.1, 101.8, 103.2, 102.8, 104.2],
        "close": [101.2, 102.4, 101.8, 103.9, 105.1, 104.4, 106.0],
        "volume": [1200, 1450, 1100, 1800, 2100, 1600, 2400],
    }
)

result = df.with_columns(
    pl.col("close").anta.ema(period=3).alias("ema_3"),
    pl.col("close").anta.rsi(period=3).alias("rsi_3"),
    pa.heikin_ashi("open", "high", "low", "close").alias("ha"),
    pl.col("close").anta.bollinger_bands(period=3).alias("bb"),
).unnest("ha", "bb")

3. Market-Wide Multi-Asset Parallel Execution (.over("ticker"))

Polars automatically partitions and parallelizes .anta expressions across all CPU cores when combined with .over("ticker"):

# Compute indicators across thousands of symbols simultaneously in Rust
universe_features = universe.with_columns(
    pl.col("close").anta.sma(20).over("ticker").alias("sma_20"),
    pl.col("close").anta.rsi(14).over("ticker").alias("rsi_14"),
    pl.col("close").anta.stc(fast_period=23, slow_period=50).over("ticker").alias("stc"),
    pl.col("close").anta.linear_regression_slope(14).over("ticker").alias("ols_slope"),
    pl.col("close").anta.obv("volume").over("ticker").alias("obv"),
)

4. Institutional Alpha & Market Microstructure Pipeline

Combine time-series liquidity/microstructure estimators with cross-sectional outlier clipping (cs_winsorize), standardization (cs_zscore), sector neutralization (neutralize), and L1 book scaling (ts_scale):

import polars as pl
import polars_anta as pa

alpha_df = (
    panel_df.with_columns(
        # 1. Time-series liquidity & price-impact estimators per asset
        pl.col("close").anta.amihud_illiquidity("volume", period=20).over("symbol").alias("amihud"),
        pl.col("close").anta.kyle_lambda("volume", period=20).over("symbol").alias("kyle_lambda"),
        pa.corwin_schultz_spread("high", "low", period=20).over("symbol").alias("cs_spread"),
        # 2. Raw momentum-reversal alpha signal
        (
            -pl.col("close").anta.ts_delta(5).over("symbol")
            * pl.col("volume").anta.ts_rank(20).over("symbol")
        ).alias("raw_alpha"),
    )
    .with_columns(
        # 3. Cross-sectional winsorization (1%/99%) & Z-score standardization per date
        pl.col("raw_alpha")
        .anta.cs_winsorize(over="date", method="quantile", lower=0.01, upper=0.99)
        .anta.cs_zscore(over="date", clip_bound=3.0)
        .alias("clean_alpha")
    )
    .with_columns(
        # 4. Sector-neutralize and scale to unit L1 long-short book ($1 long + $1 short)
        pa.ts_scale(
            pa.neutralize("clean_alpha", by="sector", over="date", standardize=True),
            a=1.0,
            over="date",
        ).alias("portfolio_weight")
    )
)

5. Factor Evaluation (IC / Quantiles) & Lightweight Vectorized Backtester

Evaluate alpha predictive power with Rank IC / ICIR, Quantile Monotonicity, and run a loop-free Vectorized Backtest (supporting 1-line entries/exits crossover triggers, automatic portfolio weight normalization, fee/slippage deduction, and formatted tearsheets):

import polars as pl
import polars_anta as pa

# A. Single-Asset 1-Line Entry/Exit Crossover Backtest & Formatted Tearsheet
bt_ema = (
    df.anta.ema(period=12, alias="ema_12")
    .anta.ema(period=26, alias="ema_26")
    .anta.backtest(
        entries=pl.col("ema_12").anta.crosses_above("ema_26"),
        exits=pl.col("ema_12").anta.crosses_below("ema_26"),
        fee_rate=0.0005,
        slippage_rate=0.0002,
        initial_capital=100_000.0,
    )
)
print(bt_ema.report())

# B. Multi-Asset WorldQuant Alpha #12 Evaluation (Rank IC + 5-Quantiles + Dollar-Neutral Backtest)
eval_df = panel_df.anta.alpha_012(group_by="symbol").anta.forward_returns(
    periods=(1, 5), group_by="symbol"
)

ic_stats = eval_df.anta.ic_summary(
    "alpha_012", "fwd_ret_1", group_by="timestamp", method="spearman"
)
quantiles_df = eval_df.anta.quantile_analysis(
    "alpha_012", "fwd_ret_1", quantiles=5, group_by="timestamp"
)

bt_portfolio = eval_df.anta.backtest(
    signal="alpha_012",
    group_by="symbol",
    time_col="timestamp",
    weight_scheme="dollar_neutral",
    fee_rate=0.0005,
    slippage_rate=0.0002,
    signal_lag=1,
    initial_capital=100_000.0,
)
print(pa.compare_strategies({"EMA Crossover": bt_ema, "Alpha #12 L/S": bt_portfolio}))

6. Interactive Jupyter Notebooks

Run our interactive tutorials directly in your browser with zero setup:

Notebook	Description	Interactive Demo
Quickstart & Live Benchmark	1-minute demo covering single-asset syntax, 500-ticker scans, and live 112x speed benchmark.
01 - Quickstart Tutorial	Comprehensive walk-through of expression syntax, pl.Struct unnesting, and plotting.
02 - Multi-Asset Portfolio Scan	Real-world 500-ticker breakout screening in 50 milliseconds using .over("ticker").
03 - Crypto Multi-Pair Momentum Scan	Cross-sectional crypto momentum & volatility ranking workflow.
04 - Vectorized Backtest & Alpha Eval	1-line entry/exit crossovers, formatted tearsheets, 5-quantile IC & dollar-neutral portfolio backtesting.

Supported Indicators (175 Indicators, Alpha Factors & Evaluation Primitives)

All 175 indicators, formulaic alphas, and evaluation functions are exported at the top level (import polars_anta as pa) and registered on .anta and .ta namespaces where applicable.

Development & Testing

# Clone the repository
git clone https://github.com/huuan26/polars-anta.git
cd polars-anta

# Install in editable mode with development dependencies
pip install -e ".[dev]"

# Run the test suite (169 unit tests across all 175 indicators, alpha factors & evaluation primitives)
pytest -v

# Run linter and formatter checks
ruff check .
ruff format --check .

Author & Community

• Author: Phan Bui Huu An — phanbuihuuan261103@gmail.com
• GitHub: @huuan26
• Discussions & Feature Requests: GitHub Discussions

License

Licensed under the Apache License, Version 2.0. See LICENSE for details.