Skip to content

CMobley7/polars-ti

BranchesTags
 
 

Repository files navigation

Polars TI - A Technical Indicators Library in Python 3

license Stars Forks Contributors Issues Closed Issues

Polars Technical Indicators (Polars TI) is an easy to use library that leverages the Pandas package with more than 150+ Indicators and Utility functions and more than 60+ TA-Lib Candlestick Patterns. Many commonly used indicators are included, such as: Candle Pattern(cdl_pattern), Simple Moving Average (sma) Moving Average Convergence Divergence (macd), Hull Exponential Moving Average (hma), Bollinger Bands (bbands), On-Balance Volume (obv), Aroon & Aroon Oscillator (aroon), Squeeze (squeeze) and many more.

Note: TA Lib must be installed to use all the Candlestick Patterns. pip install TA-Lib. If TA Lib is not installed, then only the builtin Candlestick Patterns will be available.


Table of contents


Features


Under Development

Polars TI checks if the user has some common trading packages installed including but not limited to: TA Lib, Vector BT, YFinance ... Much of which is experimental and likely to break until it stabilizes more.

  • If TA Lib installed, existing indicators will eventually get a TA Lib version.
  • Easy Downloading of ohlcv data using yfinance. See help(ti.ticker) and help(ti.yf) and examples below.
  • Some Common Performance Metrics

Installation

We recommend using uv for the fastest and most reliable installation experience. Instructions for pip and conda are also provided.

A Critical Prerequisite: TA-Lib

This library uses the TA-Lib library for many of its candlestick pattern calculations. You must install the underlying C library before installing polars-ti.

Click to expand TA-Lib installation instructions for your OS

Linux (Debian/Ubuntu)

sudo apt-get update
sudo apt-get install -y build-essential libta-lib-dev

Linux (Fedora/CentOS/RHEL)

sudo dnf install ta-lib-devel

macOS

brew install ta-lib

Windows Installing TA-Lib on Windows can be challenging. The recommended approach is to use a pre-compiled wheel (.whl) file.

  1. Go to the Unofficial Windows Binaries for Python Extension Packages website.
  2. Download the TA-Lib wheel file that matches your Python version and system architecture (e.g., TA_Lib‑0.4.28‑cp311‑cp311‑win_amd64.whl for Python 3.11 on 64-bit Windows).
  3. Open your terminal, navigate to the download directory, and install it using pip or uv: 
    # Using uv
uv pip install TA_Lib‑0.4.28‑cp311‑cp311‑win_amd64.whl

# Or using pip
pip install TA_Lib‑0.4.28‑cp311‑cp311‑win_amd64.whl

Method 1: uv (Recommended)

uv is an extremely fast Python package installer and resolver.

  1. Install uv:

    # macOS / Linux
curl -LsSf https://astral.sh/uv/install.sh | sh

# Windows
powershell -c "irm https://astral.sh/uv/install.ps1 | iex"

  2. Create and activate a virtual environment:

    # Create the venv
uv venv

# Activate it
source .venv/bin/activate

  3. Install polars-ti: To get all features, including TA-Lib patterns and yfinance integration, install the full extra:

    uv pip install "polars-ti[full]"

Method 2: pip and venv

  1. Create and activate a virtual environment:

    # Create the venv
python -m venv .venv

# Activate it (macOS/Linux)
source .venv/bin/activate

# Activate it (Windows)
.venv\Scripts\activate

  2. Install polars-ti:

    pip install "polars-ti[full]"

Method 3: conda

Using conda can simplify the installation of TA-Lib, as it handles the binary dependency automatically.

  1. Create and activate a conda environment:

    conda create -n polars-ti-env python=3.11
conda activate polars-ti-env

  2. Install TA-Lib and polars-ti: Install TA-Lib from the conda-forge channel first, then install polars-ti using pip.

    conda install -c conda-forge ta-lib
pip install "polars-ti[full]"

Versions

Stable

The pip version is the last stable release.

$ uv pip install "polars-ti[full]"

Latest Version

Best choice!

  • Includes all fixes and updates between pypi and what is covered in this README.
$ uv pip install "polars-ti[full] @ git+https://github.com/CMobley7/polars-ti"

Cutting Edge

This is the Development Version which could have bugs and other undesireable side effects. Use at own risk!

$ uv pip install "polars-ti[full] @ git+https://github.com/CMobley7/polars-ti.git@development"

Quick Start

import pandas as pd
import polars_ti as ti

df = pd.DataFrame() # Empty DataFrame

# Load data
df = pd.read_csv("path/to/symbol.csv", sep=",")
# OR if you have yfinance installed
df = df.ti.ticker("aapl")

# VWAP requires the DataFrame index to be a DatetimeIndex.
# Replace "datetime" with the appropriate column from your DataFrame
df.set_index(pd.DatetimeIndex(df["datetime"]), inplace=True)

# Calculate Returns and append to the df DataFrame
df.ti.log_return(cumulative=True, append=True)
df.ti.percent_return(cumulative=True, append=True)

# New Columns with results
df.columns

# Take a peek
df.tiil()

# vv Continue Post Processing vv

Help

Some indicator arguments have been reordered for consistency. Use help(ti.indicator_name) for more information or make a Pull Request to improve documentation.

import pandas as pd
import polars_ti as ti

# Create a DataFrame so 'ti' can be used.
df = pd.DataFrame()

# Help about this, 'ti', extension
help(df.ti)

# List of all indicators
df.ti.indicators()

# Help about an indicator such as bbands
help(ti.bbands)

Issues and Contributions

Thanks for using Polars TI!

  • Comments and Feedback

    • Have you read this document?
    • Are you running the latest version?
      • $ pip install -U git+https://github.com/CMobley7/polars-ti
    • Have you tried the Examples?
      • Did they help?
      • What is missing?
      • Could you help improve them?
    • Did you know you can easily build Custom Strategies with the Strategy Class?
    • Documentation could always be improved. Can you help contribute?

  • Bugs, Indicators or Feature Requests

    • First, search the Closed Issues before you Open a new Issue; it may have already been solved.
    • Please be as detailed as possible with reproducible code, links if any, applicable screenshots, errors, logs, and data samples. You will be asked again if you provide nothing.
      • You want a new indicator not currently listed.
      • You want an alternate version of an existing indicator.
      • The indicator does not match another website, library, broker platform, language, et al.
        • Do you have correlation analysis to back your claim?
        • Can you contribute?
    • You will be asked to fill out an Issue even if you email my personally.

Contributors

Thank you for your contributions!


Programming Conventions

Polars TI has three primary "styles" of processing Technical Indicators for your use case and/or requirements. They are: Standard, DataFrame Extension, and the Polars TI Strategy. Each with increasing levels of abstraction for ease of use. As you become more familiar with Polars TI, the simplicity and speed of using a Polars TI Strategy may become more apparent. Furthermore, you can create your own indicators through Chaining or Composition. Lastly, each indicator either returns a Series or a DataFrame in Uppercase Underscore format regardless of style.


Standard

You explicitly define the input columns and take care of the output.

  • sma10 = ti.sma(df["Close"], length=10)
    • Returns a Series with name: SMA_10
  • donchiandf = ti.donchian(df["HIGH"], df["low"], lower_length=10, upper_length=15)
    • Returns a DataFrame named DC_10_15 and column names: DCL_10_15, DCM_10_15, DCU_10_15
  • ema10_ohlc4 = ti.ema(ti.ohlc4(df["Open"], df["High"], df["Low"], df["Close"]), length=10)
    • Chaining indicators is possible but you have to be explicit.
    • Since it returns a Series named EMA_10. If needed, you may need to uniquely name it.

Polars TI DataFrame Extension

Calling df.ti will automatically lowercase OHLCVA to ohlcva: open, high, low, close, volume, adj_close. By default, df.ti will use the ohlcva for the indicator arguments removing the need to specify input columns directly.

  • sma10 = df.ti.sma(length=10)
    • Returns a Series with name: SMA_10
  • ema10_ohlc4 = df.ti.ema(close=df.ti.ohlc4(), length=10, suffix="OHLC4")
    • Returns a Series with name: EMA_10_OHLC4
    • Chaining Indicators require specifying the input like: close=df.ti.ohlc4().
  • donchiandf = df.ti.donchian(lower_length=10, upper_length=15)
    • Returns a DataFrame named DC_10_15 and column names: DCL_10_15, DCM_10_15, DCU_10_15

Same as the last three examples, but appending the results directly to the DataFrame df.

  • df.ti.sma(length=10, append=True)
    • Appends to df column name: SMA_10.
  • df.ti.ema(close=df.ti.ohlc4(append=True), length=10, suffix="OHLC4", append=True)
    • Chaining Indicators require specifying the input like: close=df.ti.ohlc4().
  • df.ti.donchian(lower_length=10, upper_length=15, append=True)
    • Appends to df with column names: DCL_10_15, DCM_10_15, DCU_10_15.

Polars TI Strategy

A Polars TI Strategy is a named group of indicators to be run by the strategy method. All Strategies use mulitprocessing except when using the col_names parameter (see below). There are different types of Strategies listed in the following section.


Here are the previous Styles implemented using a Strategy Class:

# (1) Create the Strategy
MyStrategy = ti.Strategy(
    name="DCSMA10",
    ti=[
        {"kind": "ohlc4"},
        {"kind": "sma", "length": 10},
        {"kind": "donchian", "lower_length": 10, "upper_length": 15},
        {"kind": "ema", "close": "OHLC4", "length": 10, "suffix": "OHLC4"},
    ]
)

# (2) Run the Strategy
df.ti.strategy(MyStrategy, **kwargs)



Polars TI Strategies

The Strategy Class is a simple way to name and group your favorite technical indicators by using a Data Class. Polars TI comes with two prebuilt basic Strategies to help you get started: AllStrategy and CommonStrategy. A Strategy can be as simple as the CommonStrategy or as complex as needed using Composition/Chaining.

  • When using the strategy method, all indicators will be automatically appended to the DataFrame df.
  • You are using a Chained Strategy when you have the output of one indicator as input into one or more indicators in the same Strategy.
  • Note: Use the 'prefix' and/or 'suffix' keywords to distinguish the composed indicator from it's default Series.

See the Polars TI Strategy Examples Notebook for examples including Indicator Composition/Chaining.

Strategy Requirements

  • name: Some short memorable string. Note: Case-insensitive "All" is reserved.
  • ti: A list of dicts containing keyword arguments to identify the indicator and the indicator's arguments
  • Note: A Strategy will fail when consumed by Polars TI if there is no {"kind": "indicator name"} attribute. Remember to check your spelling.

Optional Parameters

  • description: A more detailed description of what the Strategy tries to capture. Default: None
  • created: At datetime string of when it was created. Default: Automatically generated.

Types of Strategies

Builtin

# Running the Builtin CommonStrategy as mentioned above
df.ti.strategy(ti.CommonStrategy)

# The Default Strategy is the ti.AllStrategy. The following are equivalent:
df.ti.strategy()
df.ti.strategy("All")
df.ti.strategy(ti.AllStrategy)

Categorical

# List of indicator categories
df.ti.categories

# Running a Categorical Strategy only requires the Category name
df.ti.strategy("Momentum") # Default values for all Momentum indicators
df.ti.strategy("overlap", length=42) # Override all Overlap 'length' attributes

Custom

# Create your own Custom Strategy
CustomStrategy = ti.Strategy(
    name="Momo and Volatility",
    description="SMA 50,200, BBANDS, RSI, MACD and Volume SMA 20",
    ti=[
        {"kind": "sma", "length": 50},
        {"kind": "sma", "length": 200},
        {"kind": "bbands", "length": 20},
        {"kind": "rsi"},
        {"kind": "macd", "fast": 8, "slow": 21},
        {"kind": "sma", "close": "volume", "length": 20, "prefix": "VOLUME"},
    ]
)
# To run your "Custom Strategy"
df.ti.strategy(CustomStrategy)

Multiprocessing

The Polars TI strategy method utilizes multiprocessing for bulk indicator processing of all Strategy types with ONE EXCEPTION! When using the col_names parameter to rename resultant column(s), the indicators in ti array will be ran in order.

# VWAP requires the DataFrame index to be a DatetimeIndex.
# * Replace "datetime" with the appropriate column from your DataFrame
df.set_index(pd.DatetimeIndex(df["datetime"]), inplace=True)

# Runs and appends all indicators to the current DataFrame by default
# The resultant DataFrame will be large.
df.ti.strategy()
# Or the string "all"
df.ti.strategy("all")
# Or the ti.AllStrategy
df.ti.strategy(ti.AllStrategy)

# Use verbose if you want to make sure it is running.
df.ti.strategy(verbose=True)

# Use timed if you want to see how long it takes to run.
df.ti.strategy(timed=True)

# Choose the number of cores to use. Default is all available cores.
# For no multiprocessing, set this value to 0.
df.ti.cores = 4

# Maybe you do not want certain indicators.
# Just exclude (a list of) them.
df.ti.strategy(exclude=["bop", "mom", "percent_return", "wcp", "pvi"], verbose=True)

# Perhaps you want to use different values for indicators.
# This will run ALL indicators that have fast or slow as parameters.
# Check your results and exclude as necessary.
df.ti.strategy(fast=10, slow=50, verbose=True)

# Sanity check. Make sure all the columns are there
df.columns

Custom Strategy without Multiprocessing

Remember These will not be utilizing multiprocessing

NonMPStrategy = ti.Strategy(
    name="EMAs, BBs, and MACD",
    description="Non Multiprocessing Strategy by rename Columns",
    ti=[
        {"kind": "ema", "length": 8},
        {"kind": "ema", "length": 21},
        {"kind": "bbands", "length": 20, "col_names": ("BBL", "BBM", "BBU")},
        {"kind": "macd", "fast": 8, "slow": 21, "col_names": ("MACD", "MACD_H", "MACD_S")}
    ]
)
# Run it
df.ti.strategy(NonMPStrategy)



DataFrame Properties

adjusted

# Set ta to default to an adjusted column, 'adj_close', overriding default 'close'.
df.ti.adjusted = "adj_close"
df.ti.sma(length=10, append=True)

# To reset back to 'close', set adjusted back to None.
df.ti.adjusted = None

categories

# List of Polars TI categories.
df.ti.categories

cores

# Set the number of cores to use for strategy multiprocessing
# Defaults to the number of cpus you have.
df.ti.cores = 4

# Set the number of cores to 0 for no multiprocessing.
df.ti.cores = 0

# Returns the number of cores you set or your default number of cpus.
df.ti.cores

datetime_ordered

# The 'datetime_ordered' property returns True if the DataFrame
# index is of Pandas datetime64 and df.index[0] < df.index[-1].
# Otherwise it returns False.
df.ti.datetime_ordered

exchange

# Sets the Exchange to use when calculating the last_run property. Default: "NYSE"
df.ti.exchange

# Set the Exchange to use.
# Available Exchanges: "ASX", "BMF", "DIFX", "FWB", "HKE", "JSE", "LSE", "NSE", "NYSE", "NZSX", "RTS", "SGX", "SSE", "TSE", "TSX"
df.ti.exchange = "LSE"

last_run

# Returns the time Polars TI was last run as a string.
df.ti.last_run

reverse

# The 'reverse' is a helper property that returns the DataFrame
# in reverse order.
df.ti.reverse

prefix & suffix

# Applying a prefix to the name of an indicator.
prehl2 = df.ti.hl2(prefix="pre")
print(prehl2.name)  # "pre_HL2"

# Applying a suffix to the name of an indicator.
endhl2 = df.ti.hl2(suffix="post")
print(endhl2.name)  # "HL2_post"

# Applying a prefix and suffix to the name of an indicator.
bothhl2 = df.ti.hl2(prefix="pre", suffix="post")
print(bothhl2.name)  # "pre_HL2_post"

time_range

# Returns the time range of the DataFrame as a float.
# By default, it returns the time in "years"
df.ti.time_range

# Available time_ranges include: "years", "months", "weeks", "days", "hours", "minutes". "seconds"
df.ti.time_range = "days"
df.ti.time_range # prints DataFrame time in "days" as float

to_utc

# Sets the DataFrame index to UTC format.
df.ti.to_utc



DataFrame Methods

constants

import numpy as np

# Add constant '1' to the DataFrame
df.ti.constants(True, [1])
# Remove constant '1' to the DataFrame
df.ti.constants(False, [1])

# Adding constants for charting
import numpy as np
chart_lines = np.append(np.arange(-4, 5, 1), np.arange(-100, 110, 10))
df.ti.constants(True, chart_lines)
# Removing some constants from the DataFrame
df.ti.constants(False, np.array([-60, -40, 40, 60]))

indicators

# Prints the indicators and utility functions
df.ti.indicators()

# Returns a list of indicators and utility functions
ind_list = df.ti.indicators(as_list=True)

# Prints the indicators and utility functions that are not in the excluded list
df.ti.indicators(exclude=["cg", "pgo", "ui"])
# Returns a list of the indicators and utility functions that are not in the excluded list
smaller_list = df.ti.indicators(exclude=["cg", "pgo", "ui"], as_list=True)

ticker

# Download Chart history using yfinance. (pip install yfinance) https://github.com/ranaroussi/yfinance
# It uses the same keyword arguments as yfinance (excluding start and end)
df = df.ti.ticker("aapl") # Default ticker is "SPY"

# Period is used instead of start/end
# Valid periods: 1d,5d,1mo,3mo,6mo,1y,2y,5y,10y,ytd,max
# Default: "max"
df = df.ti.ticker("aapl", period="1y") # Gets this past year

# History by Interval by interval (including intraday if period < 60 days)
# Valid intervals: 1m,2m,5m,15m,30m,60m,90m,1h,1d,5d,1wk,1mo,3mo
# Default: "1d"
df = df.ti.ticker("aapl", period="1y", interval="1wk") # Gets this past year in weeks
df = df.ti.ticker("aapl", period="1mo", interval="1h") # Gets this past month in hours

# BUT WAIT!! THERE'S MORE!!
help(ti.yf)



Indicators (by Category)

Candles (64)

Patterns that are not bold, require TA-Lib to be installed: pip install TA-Lib

  • 2crows
  • 3blackcrows
  • 3inside
  • 3linestrike
  • 3outside
  • 3starsinsouth
  • 3whitesoldiers
  • abandonedbaby
  • advanceblock
  • belthold
  • breakaway
  • closingmarubozu
  • concealbabyswall
  • counterattack
  • darkcloudcover
  • doji
  • dojistar
  • dragonflydoji
  • engulfing
  • eveningdojistar
  • eveningstar
  • gapsidesidewhite
  • gravestonedoji
  • hammer
  • hangingman
  • harami
  • haramicross
  • highwave
  • hikkake
  • hikkakemod
  • homingpigeon
  • identical3crows
  • inneck
  • inside
  • invertedhammer
  • kicking
  • kickingbylength
  • ladderbottom
  • longleggeddoji
  • longline
  • marubozu
  • matchinglow
  • mathold
  • morningdojistar
  • morningstar
  • onneck
  • piercing
  • rickshawman
  • risefall3methods
  • separatinglines
  • shootingstar
  • shortline
  • spinningtop
  • stalledpattern
  • sticksandwich
  • takuri
  • tasukigap
  • thrusting
  • tristar
  • unique3river
  • upsidegap2crows
  • xsidegap3methods
  • Heikin-Ashi: ha
  • Z Score: cdl_z
# Get all candle patterns (This is the default behaviour)
df = df.ti.cdl_pattern(name="all")

# Get only one pattern
df = df.ti.cdl_pattern(name="doji")

# Get some patterns
df = df.ti.cdl_pattern(name=["doji", "inside"])

Cycles (2)

  • Even Better Sinewave: ebsw
  • Reflex: reflex

Momentum (43)

  • Awesome Oscillator: ao
  • Absolute Price Oscillator: apo
  • Bias: bias
  • Balance of Power: bop
  • BRAR: brar
  • Commodity Channel Index: cci
  • Chande Forecast Oscillator: cfo
  • Center of Gravity: cg
  • Chande Momentum Oscillator: cmo
  • Coppock Curve: coppock
  • Connors RSI (CRSI): crsi
  • Correlation Trend Indicator: cti
    • A wrapper for ti.linreg(series, r=True)
  • Directional Movement: dm
  • Efficiency Ratio: er
  • Elder Ray Index: eri
  • Fisher Transform: fisher
  • Inertia: inertia
  • KDJ: kdj
  • KST Oscillator: kst
  • Moving Average Convergence Divergence: macd
  • Momentum: mom
  • Pretty Good Oscillator: pgo
  • Percentage Price Oscillator: ppo
  • Psychological Line: psl
  • Quantitative Qualitative Estimation: qqe
  • Rate of Change: roc
  • Relative Strength Index: rsi
  • Relative Strength Xtra: rsx
  • Relative Vigor Index: rvgi
  • Slope: slope
  • Smart Money Comcept: smc
  • SMI Ergodic smi
  • Squeeze: squeeze
    • Default is John Carter's. Enable Lazybear's with lazybear=True
  • Squeeze Pro: squeeze_pro
  • Schaff Trend Cycle: stc
  • Stochastic Oscillator: stoch
  • Fast Stochastic: stochf
  • Stochastic RSI: stochrsi
  • True Momentum Oscillator: tmo
  • Trix: trix
  • True Strength Index: tsi
  • Ultimate Oscillator: uo
  • Williams %R: willr

Overlap (36)

  • Bill Williams Alligator: alligator
  • Arnaud Legoux Moving Average: alma
  • Double Exponential Moving Average: dema
  • Exponential Moving Average: ema
  • Fibonacci's Weighted Moving Average: fwma
  • Gann High-Low Activator: hilo
  • High-Low Average: hl2
  • High-Low-Close Average: hlc3
    • Commonly known as 'Typical Price' in Technical Analysis literature
  • Hull Exponential Moving Average: hma
  • Holt-Winter Moving Average: hwma
  • Ichimoku Kinkō Hyō: ichimoku
    • Returns two DataFrames. For more information: help(ti.ichimoku).
    • lookahead=False drops the Chikou Span Column to prevent potential data leak.
  • Jurik Moving Average: jma
  • Kaufman's Adaptive Moving Average: kama
  • Linear Regression: linreg
  • Ehler's MESA Adaptive Moving Average: mama
  • McGinley Dynamic: mcgd
  • Midpoint: midpoint
  • Midprice: midprice
  • Open-High-Low-Close Average: ohlc4
  • Pivot Points: pivots
  • Pascal's Weighted Moving Average: pwma
  • WildeR's Moving Average: rma
  • Sine Weighted Moving Average: sinwma
  • Simple Moving Average: sma
  • SMoothed Moving Average: ssma
  • Ehler's Super Smoother Filter: ssf
  • Ehler's 3 Pole Super Smoother Filter: ssf3
  • Supertrend: supertrend
  • Symmetric Weighted Moving Average: swma
  • T3 Moving Average: t3
  • Triple Exponential Moving Average: tema
  • Triangular Moving Average: trima
  • Variable Index Dynamic Average: vidya
  • Weighted Closing Price: wcp
  • Weighted Moving Average: wma
  • Zero Lag Moving Average: zlma

Performance (3)

Use parameter: cumulative=True for cumulative results.

  • Draw Down: drawdown
  • Log Return: log_return
  • Percent Return: percent_return

Statistics (10)

  • Entropy: entropy
  • Kurtosis: kurtosis
  • Mean Absolute Deviation: mad
  • Median: median
  • Quantile: quantile
  • Skew: skew
  • Standard Deviation: stdev
  • Think or Swim Standard Deviation All: tos_stdevall
  • Variance: variance
  • Z Score: zscore

Trend (24)

  • Average Directional Movement Index: adx
    • Also includes dmp and dmn in the resultant DataFrame.
  • Alpha Trend: alphatrend
  • Archer Moving Averages Trends: amat
  • Aroon & Aroon Oscillator: aroon
  • Choppiness Index: chop
  • Chande Kroll Stop: cksp
  • Decay: decay
  • Decreasing: decreasing
  • Detrend Price Oscillator: dpo
  • Hilbert Transform TrendLine: ht_trendline
  • Detrended Price Oscillator: dpo
    • Set lookahead=False to disable centering and remove potential data leak.
  • Increasing: increasing
  • Long Run: long_run
  • Parabolic Stop and Reverse: psar
  • Q Stick: qstick
  • Random Walk Index: rwi
  • Short Run: short_run
  • Trendflex: trendflex
  • Trend Signals: tsignals
  • TTM Trend: ttm_trend
  • Vertical Horizontal Filter: vhf
  • Vortex: vortex
  • Cross Signals: xsignals
  • Zigzag: zigzag

Volatility (16)

  • Aberration: aberration
  • Acceleration Bands: accbands
  • Average True Range: atr
  • ATR Trailing Stop: atrts
  • Bollinger Bands: bbands
  • Chandelier Exit: chandelier_exit
  • Donchian Channel: donchian
  • Holt-Winter Channel: hwc
  • Keltner Channel: kc
  • Mass Index: massi
  • Normalized Average True Range: natr
  • Price Distance: pdist
  • Relative Volatility Index: rvi
  • Elder's Thermometer: thermo
  • True Range: true_range
  • Ulcer Index: ui

Volume (20)

  • Accumulation/Distribution Index: ad
  • Accumulation/Distribution Oscillator: adosc
  • Archer On-Balance Volume: aobv
  • Chaikin Money Flow: cmf
  • Elder's Force Index: efi
  • Ease of Movement: eom
  • Klinger Volume Oscillator: kvo
  • Money Flow Index: mfi
  • Negative Volume Index: nvi
  • On-Balance Volume: obv
  • Positive Volume Index: pvi
  • Percentage Volume Oscillator: pvo
  • Price-Volume: pvol
  • Price Volume Rank: pvr
  • Price Volume Trend: pvt
  • Volume Heatmap: vhm
  • Volume Profile: vp
  • Volume Weighted Average Price: vwap
    • Requires the DataFrame index to be a DatetimeIndex
  • Volume Weighted Moving Average: vwma
  • Worden Brothers' Time Segmented Value: wb_tsv



Backtesting with vectorbt

For easier integration with vectorbt's Portfolio from_signals method, the ti.trend_return method has been replaced with ti.tsignals method to simplify the generation of trading signals. For a comprehensive example, see the example Jupyter Notebook VectorBT Backtest with Polars TI in the examples directory.


Brief example

  • See the vectorbt website more options and examples.
import pandas as pd
import polars_ti as ti
import vectorbt as vbt

df = pd.DataFrame().ti.ticker("AAPL") # requires 'yfinance' installed

# Create the "Golden Cross" 
df["GC"] = df.ti.sma(50, append=True) > df.ti.sma(200, append=True)

# Create boolean Signals(TS_Entries, TS_Exits) for vectorbt
golden = df.ti.tsignals(df.GC, asbool=True, append=True)

# Sanity Check (Ensure data exists)
print(df)

# Create the Signals Portfolio
pf = vbt.Portfolio.from_signals(df.close, entries=golden.TS_Entries, exits=golden.TS_Exits, freq="D", init_cash=100_000, fees=0.0025, slippage=0.0025)

# Print Portfolio Stats and Return Stats
print(pf.stats())
print(pf.returns_stats())



Changes

General


Breaking / Depreciated Indicators


New Indicators


Updated Indicators


Sources

Original TA-LIB | TradingView | Sierra Chart | MQL5 | FM Labs | Pro Real Code | User 42

About

Technical Indicators - Polars TI is an easy to use Python 3 Pandas Extension with 130+ Indicators

github.com/CMobley7/polars-ti

Resources

Readme

License

MIT license

Code of conduct

Code of conduct
Activity

Stars

1 star

Watchers

0 watching

Forks

0 forks
Report repository

Releases

1 tags

Packages

No packages published

Languages

  • Python 99.9%
  • Makefile 0.1%