# TA-Lib
This is a Python wrapper for [TA-LIB](http://ta-lib.org) based on Cython
instead of SWIG. From the homepage:
> TA-Lib is widely used by trading software developers requiring to perform
> technical analysis of financial market data.
>
> * Includes 150+ indicators such as ADX, MACD, RSI, Stochastic, Bollinger
> Bands, etc.
> * Candlestick pattern recognition
> * Open-source API for C/C++, Java, Perl, Python and 100% Managed .NET
The original Python bindings included with TA-Lib use
[SWIG](http://swig.org) which unfortunately are difficult to install and
aren't as efficient as they could be. Therefore this project uses
[Cython](https://cython.org) and [Numpy](https://numpy.org) to efficiently
and cleanly bind to TA-Lib -- producing results 2-4 times faster than the
SWIG interface.
In addition, this project also supports the use of the
[Polars](https://www.pola.rs) and [Pandas](https://pandas.pydata.org)
libraries.
## Installation
You can install from PyPI:
```
$ python -m pip install TA-Lib
```
Or checkout the sources and run ``setup.py`` yourself:
```
$ python setup.py install
```
It also appears possible to install via
[Conda Forge](https://anaconda.org/conda-forge/ta-lib):
```
$ conda install -c conda-forge ta-lib
```
### Dependencies
To use TA-Lib for python, you need to have the
[TA-Lib](http://ta-lib.org/hdr_dw.html) already installed. You should
probably follow their installation directions for your platform, but some
suggestions are included below for reference.
> Some Conda Forge users have reported success installing the underlying TA-Lib C
> library using [the libta-lib package](https://anaconda.org/conda-forge/libta-lib):
>
> ``$ conda install -c conda-forge libta-lib``
##### Mac OS X
You can simply install using Homebrew:
```
$ brew install ta-lib
```
If you are using Apple Silicon, such as the M1 processors, and building mixed
architecture Homebrew projects, you might want to make sure it's being built
for your architecture:
```
$ arch -arm64 brew install ta-lib
```
And perhaps you can set these before installing with ``pip``:
```
$ export TA_INCLUDE_PATH="$(brew --prefix ta-lib)/include"
$ export TA_LIBRARY_PATH="$(brew --prefix ta-lib)/lib"
```
You might also find this helpful, particularly if you have tried several
different installations without success:
```
$ your-arm64-python -m pip install --no-cache-dir ta-lib
```
##### Windows
Download [ta-lib-0.4.0-msvc.zip](https://sourceforge.net/projects/ta-lib/files/ta-lib/0.4.0/ta-lib-0.4.0-msvc.zip/download)
and unzip to ``C:\ta-lib``.
> This is a 32-bit binary release. If you want to use 64-bit Python, you will
> need to build a 64-bit version of the library. Some unofficial instructions
> for building on 64-bit Windows 10 or Windows 11, here for reference:
>
> 1. Download and Unzip ``ta-lib-0.4.0-msvc.zip``
> 2. Move the Unzipped Folder ``ta-lib`` to ``C:\``
> 3. Download and Install Visual Studio Community (2015 or later)
> * Remember to Select ``[Visual C++]`` Feature
> 4. Build TA-Lib Library
> * From Windows Start Menu, Start ``[VS2015 x64 Native Tools Command
> Prompt]``
> * Move to ``C:\ta-lib\c\make\cdr\win32\msvc``
> * Build the Library ``nmake``
You might also try these unofficial windows binary wheels for both 32-bit
and 64-bit:
https://github.com/cgohlke/talib-build/
##### Linux
Download
[ta-lib-0.4.0-src.tar.gz](https://sourceforge.net/projects/ta-lib/files/ta-lib/0.4.0/ta-lib-0.4.0-src.tar.gz/download)
and:
```
$ tar -xzf ta-lib-0.4.0-src.tar.gz
$ cd ta-lib/
$ ./configure --prefix=/usr
$ make
$ sudo make install
```
> If you build ``TA-Lib`` using ``make -jX`` it will fail but that's OK!
> Simply rerun ``make -jX`` followed by ``[sudo] make install``.
Note: if your directory path includes spaces, the installation will probably
fail with ``No such file or directory`` errors.
### Troubleshooting
If you get a warning that looks like this:
```
setup.py:79: UserWarning: Cannot find ta-lib library, installation may fail.
warnings.warn('Cannot find ta-lib library, installation may fail.')
```
This typically means ``setup.py`` can't find the underlying ``TA-Lib``
library, a dependency which needs to be installed.
---
If you installed the underlying ``TA-Lib`` library with a custom prefix
(e.g., with ``./configure --prefix=$PREFIX``), then when you go to install
this python wrapper you can specify additional search paths to find the
library and include files for the underlying ``TA-Lib`` library using the
``TA_LIBRARY_PATH`` and ``TA_INCLUDE_PATH`` environment variables:
```sh
$ export TA_LIBRARY_PATH=$PREFIX/lib
$ export TA_INCLUDE_PATH=$PREFIX/include
$ python setup.py install # or pip install ta-lib
```
---
Sometimes installation will produce build errors like this:
```
talib/_ta_lib.c:601:10: fatal error: ta-lib/ta_defs.h: No such file or directory
601 | #include "ta-lib/ta_defs.h"
| ^~~~~~~~~~~~~~~~~~
compilation terminated.
```
or:
```
common.obj : error LNK2001: unresolved external symbol TA_SetUnstablePeriod
common.obj : error LNK2001: unresolved external symbol TA_Shutdown
common.obj : error LNK2001: unresolved external symbol TA_Initialize
common.obj : error LNK2001: unresolved external symbol TA_GetUnstablePeriod
common.obj : error LNK2001: unresolved external symbol TA_GetVersionString
```
This typically means that it can't find the underlying ``TA-Lib`` library, a
dependency which needs to be installed. On Windows, this could be caused by
installing the 32-bit binary distribution of the underlying ``TA-Lib`` library,
but trying to use it with 64-bit Python.
---
Sometimes installation will fail with errors like this:
```
talib/common.c:8:22: fatal error: pyconfig.h: No such file or directory
#include "pyconfig.h"
^
compilation terminated.
error: command 'x86_64-linux-gnu-gcc' failed with exit status 1
```
This typically means that you need the Python headers, and should run
something like:
```
$ sudo apt-get install python3-dev
```
---
Sometimes building the underlying ``TA-Lib`` library has errors running
``make`` that look like this:
```
../libtool: line 1717: cd: .libs/libta_lib.lax/libta_abstract.a: No such file or directory
make[2]: *** [libta_lib.la] Error 1
make[1]: *** [all-recursive] Error 1
make: *** [all-recursive] Error 1
```
This might mean that the directory path to the underlying ``TA-Lib`` library
has spaces in the directory names. Try putting it in a path that does not have
any spaces and trying again.
---
Sometimes you might get this error running ``setup.py``:
```
/usr/include/limits.h:26:10: fatal error: bits/libc-header-start.h: No such file or directory
#include <bits/libc-header-start.h>
^~~~~~~~~~~~~~~~~~~~~~~~~~
```
This is likely an issue with trying to compile for 32-bit platform but
without the appropriate headers. You might find some success looking at the
first answer to [this question](https://stackoverflow.com/questions/54082459/fatal-error-bits-libc-header-start-h-no-such-file-or-directory-while-compili).
---
If you get an error on macOS like this:
```
code signature in <141BC883-189B-322C-AE90-CBF6B5206F67>
'python3.9/site-packages/talib/_ta_lib.cpython-39-darwin.so' not valid for
use in process: Trying to load an unsigned library)
```
You might look at [this question](https://stackoverflow.com/questions/69610572/how-can-i-solve-the-below-error-while-importing-nltk-package)
and use ``xcrun codesign`` to fix it.
---
If you wonder why ``STOCHRSI`` gives you different results than you expect,
probably you want ``STOCH`` applied to ``RSI``, which is a little different
than the ``STOCHRSI`` which is ``STOCHF`` applied to ``RSI``:
```python
>>> import talib
>>> import numpy as np
>>> c = np.random.randn(100)
# this is the library function
>>> k, d = talib.STOCHRSI(c)
# this produces the same result, calling STOCHF
>>> rsi = talib.RSI(c)
>>> k, d = talib.STOCHF(rsi, rsi, rsi)
# you might want this instead, calling STOCH
>>> rsi = talib.RSI(c)
>>> k, d = talib.STOCH(rsi, rsi, rsi)
```
---
If the build appears to hang, you might be running on a VM with not enough
memory -- try 1 GB or 2 GB.
---
If you get "permission denied" errors such as this, you might need to give
your user access to the location where the underlying TA-Lib C library is
installed -- or install it to a user-accessible location.
```
talib/_ta_lib.c:747:28: fatal error: /usr/include/ta-lib/ta_defs.h: Permission denied
#include "ta-lib/ta-defs.h"
^
compilation terminated
error: command 'gcc' failed with exit status 1
```
---
If you're having trouble compiling the underlying TA-Lib C library on ARM64,
you might need to configure it with an explicit build type before running
``make`` and ``make install``, for example:
```
$ ./configure --build=aarch64-unknown-linux-gnu
```
This is caused by old ``config.guess`` file, so another way to solve this is
to copy a newer version of config.guess into the underyling TA-Lib C library
sources:
```
$ cp /usr/share/automake-1.16/config.guess /path/to/extracted/ta-lib/config.guess
```
And then re-run configure:
```
$ ./configure
```
## Function API
Similar to TA-Lib, the Function API provides a lightweight wrapper of the
exposed TA-Lib indicators.
Each function returns an output array and have default values for their
parameters, unless specified as keyword arguments. Typically, these functions
will have an initial "lookback" period (a required number of observations
before an output is generated) set to ``NaN``.
For convenience, the Function API supports both ``numpy.ndarray`` and
``pandas.Series`` and ``polars.Series`` inputs.
All of the following examples use the Function API:
```python
import numpy as np
import talib
close = np.random.random(100)
```
Calculate a simple moving average of the close prices:
```python
output = talib.SMA(close)
```
Calculating bollinger bands, with triple exponential moving average:
```python
from talib import MA_Type
upper, middle, lower = talib.BBANDS(close, matype=MA_Type.T3)
```
Calculating momentum of the close prices, with a time period of 5:
```python
output = talib.MOM(close, timeperiod=5)
```
##### NaN's
The underlying TA-Lib C library handles NaN's in a sometimes surprising manner
by typically propagating NaN's to the end of the output, for example:
```python
>>> c = np.array([1.0, 2.0, 3.0, np.nan, 4.0, 5.0, 6.0])
>>> talib.SMA(c, 3)
array([nan, nan, 2., nan, nan, nan, nan])
```
You can compare that to a Pandas rolling mean, where their approach is to
output NaN until enough "lookback" values are observed to generate new outputs:
```python
>>> c = pandas.Series([1.0, 2.0, 3.0, np.nan, 4.0, 5.0, 6.0])
>>> c.rolling(3).mean()
0 NaN
1 NaN
2 2.0
3 NaN
4 NaN
5 NaN
6 5.0
dtype: float64
```
## Abstract API
If you're already familiar with using the function API, you should feel right
at home using the Abstract API.
Every function takes a collection of named inputs, either a ``dict`` of
``numpy.ndarray`` or ``pandas.Series`` or ``polars.Series``, or a
``pandas.DataFrame`` or ``polars.DataFrame``. If a ``pandas.DataFrame`` or
``polars.DataFrame`` is provided, the output is returned as the same type
with named output columns.
For example, inputs could be provided for the typical "OHLCV" data:
```python
import numpy as np
# note that all ndarrays must be the same length!
inputs = {
'open': np.random.random(100),
'high': np.random.random(100),
'low': np.random.random(100),
'close': np.random.random(100),
'volume': np.random.random(100)
}
```
Functions can either be imported directly or instantiated by name:
```python
from talib import abstract
# directly
SMA = abstract.SMA
# or by name
SMA = abstract.Function('sma')
```
From there, calling functions is basically the same as the function API:
```python
from talib.abstract import *
# uses close prices (default)
output = SMA(inputs, timeperiod=25)
# uses open prices
output = SMA(inputs, timeperiod=25, price='open')
# uses close prices (default)
upper, middle, lower = BBANDS(inputs, 20, 2.0, 2.0)
# uses high, low, close (default)
slowk, slowd = STOCH(inputs, 5, 3, 0, 3, 0) # uses high, low, close by default
# uses high, low, open instead
slowk, slowd = STOCH(inputs, 5, 3, 0, 3, 0, prices=['high', 'low', 'open'])
```
## Streaming API
An experimental Streaming API was added that allows users to compute the latest
value of an indicator. This can be faster than using the Function API, for
example in an application that receives streaming data, and wants to know just
the most recent updated indicator value.
```python
import talib
from talib import stream
close = np.random.random(100)
# the Function API
output = talib.SMA(close)
# the Streaming API
latest = stream.SMA(close)
# the latest value is the same as the last output value
assert (output[-1] - latest) < 0.00001
```
## Supported Indicators and Functions
We can show all the TA functions supported by TA-Lib, either as a ``list`` or
as a ``dict`` sorted by group (e.g. "Overlap Studies", "Momentum Indicators",
etc):
```python
import talib
# list of functions
for name in talib.get_functions():
print(name)
# dict of functions by group
for group, names in talib.get_function_groups().items():
print(group)
for name in names:
print(f" {name}")
```
### Indicator Groups
* Overlap Studies
* Momentum Indicators
* Volume Indicators
* Volatility Indicators
* Price Transform
* Cycle Indicators
* Pattern Recognition
##### Overlap Studies
```
BBANDS Bollinger Bands
DEMA Double Exponential Moving Average
EMA Exponential Moving Average
HT_TRENDLINE Hilbert Transform - Instantaneous Trendline
KAMA Kaufman Adaptive Moving Average
MA Moving average
MAMA MESA Adaptive Moving Average
MAVP Moving average with variable period
MIDPOINT MidPoint over period
MIDPRICE Midpoint Price over period
SAR Parabolic SAR
SAREXT Parabolic SAR - Extended
SMA Simple Moving Average
T3 Triple Exponential Moving Average (T3)
TEMA Triple Exponential Moving Average
TRIMA Triangular Moving Average
WMA Weighted Moving Average
```
##### Momentum Indicators
```
ADX Average Directional Movement Index
ADXR Average Directional Movement Index Rating
APO Absolute Price Oscillator
AROON Aroon
AROONOSC Aroon Oscillator
BOP Balance Of Power
CCI Commodity Channel Index
CMO Chande Momentum Oscillator
DX Directional Movement Index
MACD Moving Average Convergence/Divergence
MACDEXT MACD with controllable MA type
MACDFIX Moving Average Convergence/Divergence Fix 12/26
MFI Money Flow Index
MINUS_DI Minus Directional Indicator
MINUS_DM Minus Directional Movement
MOM Momentum
PLUS_DI Plus Directional Indicator
PLUS_DM Plus Directional Movement
PPO Percentage Price Oscillator
ROC Rate of change : ((price/prevPrice)-1)*100
ROCP Rate of change Percentage: (price-prevPrice)/prevPrice
ROCR Rate of change ratio: (price/prevPrice)
ROCR100 Rate of change ratio 100 scale: (price/prevPrice)*100
RSI Relative Strength Index
STOCH Stochastic
STOCHF Stochastic Fast
STOCHRSI Stochastic Relative Strength Index
TRIX 1-day Rate-Of-Change (ROC) of a Triple Smooth EMA
ULTOSC Ultimate Oscillator
WILLR Williams' %R
```
##### Volume Indicators
```
AD Chaikin A/D Line
ADOSC Chaikin A/D Oscillator
OBV On Balance Volume
```
##### Cycle Indicators
```
HT_DCPERIOD Hilbert Transform - Dominant Cycle Period
HT_DCPHASE Hilbert Transform - Dominant Cycle Phase
HT_PHASOR Hilbert Transform - Phasor Components
HT_SINE Hilbert Transform - SineWave
HT_TRENDMODE Hilbert Transform - Trend vs Cycle Mode
```
##### Price Transform
```
AVGPRICE Average Price
MEDPRICE Median Price
TYPPRICE Typical Price
WCLPRICE Weighted Close Price
```
##### Volatility Indicators
```
ATR Average True Range
NATR Normalized Average True Range
TRANGE True Range
```
##### Pattern Recognition
```
CDL2CROWS Two Crows
CDL3BLACKCROWS Three Black Crows
CDL3INSIDE Three Inside Up/Down
CDL3LINESTRIKE Three-Line Strike
CDL3OUTSIDE Three Outside Up/Down
CDL3STARSINSOUTH Three Stars In The South
CDL3WHITESOLDIERS Three Advancing White Soldiers
CDLABANDONEDBABY Abandoned Baby
CDLADVANCEBLOCK Advance Block
CDLBELTHOLD Belt-hold
CDLBREAKAWAY Breakaway
CDLCLOSINGMARUBOZU Closing Marubozu
CDLCONCEALBABYSWALL Concealing Baby Swallow
CDLCOUNTERATTACK Counterattack
CDLDARKCLOUDCOVER Dark Cloud Cover
CDLDOJI Doji
CDLDOJISTAR Doji Star
CDLDRAGONFLYDOJI Dragonfly Doji
CDLENGULFING Engulfing Pattern
CDLEVENINGDOJISTAR Evening Doji Star
CDLEVENINGSTAR Evening Star
CDLGAPSIDESIDEWHITE Up/Down-gap side-by-side white lines
CDLGRAVESTONEDOJI Gravestone Doji
CDLHAMMER Hammer
CDLHANGINGMAN Hanging Man
CDLHARAMI Harami Pattern
CDLHARAMICROSS Harami Cross Pattern
CDLHIGHWAVE High-Wave Candle
CDLHIKKAKE Hikkake Pattern
CDLHIKKAKEMOD Modified Hikkake Pattern
CDLHOMINGPIGEON Homing Pigeon
CDLIDENTICAL3CROWS Identical Three Crows
CDLINNECK In-Neck Pattern
CDLINVERTEDHAMMER Inverted Hammer
CDLKICKING Kicking
CDLKICKINGBYLENGTH Kicking - bull/bear determined by the longer marubozu
CDLLADDERBOTTOM Ladder Bottom
CDLLONGLEGGEDDOJI Long Legged Doji
CDLLONGLINE Long Line Candle
CDLMARUBOZU Marubozu
CDLMATCHINGLOW Matching Low
CDLMATHOLD Mat Hold
CDLMORNINGDOJISTAR Morning Doji Star
CDLMORNINGSTAR Morning Star
CDLONNECK On-Neck Pattern
CDLPIERCING Piercing Pattern
CDLRICKSHAWMAN Rickshaw Man
CDLRISEFALL3METHODS Rising/Falling Three Methods
CDLSEPARATINGLINES Separating Lines
CDLSHOOTINGSTAR Shooting Star
CDLSHORTLINE Short Line Candle
CDLSPINNINGTOP Spinning Top
CDLSTALLEDPATTERN Stalled Pattern
CDLSTICKSANDWICH Stick Sandwich
CDLTAKURI Takuri (Dragonfly Doji with very long lower shadow)
CDLTASUKIGAP Tasuki Gap
CDLTHRUSTING Thrusting Pattern
CDLTRISTAR Tristar Pattern
CDLUNIQUE3RIVER Unique 3 River
CDLUPSIDEGAP2CROWS Upside Gap Two Crows
CDLXSIDEGAP3METHODS Upside/Downside Gap Three Methods
```
##### Statistic Functions
```
BETA Beta
CORREL Pearson's Correlation Coefficient (r)
LINEARREG Linear Regression
LINEARREG_ANGLE Linear Regression Angle
LINEARREG_INTERCEPT Linear Regression Intercept
LINEARREG_SLOPE Linear Regression Slope
STDDEV Standard Deviation
TSF Time Series Forecast
VAR Variance
```
Raw data
{
"_id": null,
"home_page": "http://github.com/ta-lib/ta-lib-python",
"name": "TA-Lib",
"maintainer": null,
"docs_url": null,
"requires_python": null,
"maintainer_email": null,
"keywords": null,
"author": "John Benediktsson",
"author_email": "mrjbq7@gmail.com",
"download_url": "https://files.pythonhosted.org/packages/37/f5/749d1b1e4d2eb22b37da5c96529b01f8c4daaf9e30428166cd3185832500/TA-Lib-0.4.32.tar.gz",
"platform": null,
"description": "# TA-Lib\n\n\n\nThis is a Python wrapper for [TA-LIB](http://ta-lib.org) based on Cython\ninstead of SWIG. From the homepage:\n\n> TA-Lib is widely used by trading software developers requiring to perform\n> technical analysis of financial market data.\n>\n> * Includes 150+ indicators such as ADX, MACD, RSI, Stochastic, Bollinger\n> Bands, etc.\n> * Candlestick pattern recognition\n> * Open-source API for C/C++, Java, Perl, Python and 100% Managed .NET\n\nThe original Python bindings included with TA-Lib use\n[SWIG](http://swig.org) which unfortunately are difficult to install and\naren't as efficient as they could be. Therefore this project uses\n[Cython](https://cython.org) and [Numpy](https://numpy.org) to efficiently\nand cleanly bind to TA-Lib -- producing results 2-4 times faster than the\nSWIG interface.\n\nIn addition, this project also supports the use of the\n[Polars](https://www.pola.rs) and [Pandas](https://pandas.pydata.org)\nlibraries.\n\n## Installation\n\nYou can install from PyPI:\n\n```\n$ python -m pip install TA-Lib\n```\n\nOr checkout the sources and run ``setup.py`` yourself:\n\n```\n$ python setup.py install\n```\n\nIt also appears possible to install via \n[Conda Forge](https://anaconda.org/conda-forge/ta-lib):\n\n```\n$ conda install -c conda-forge ta-lib\n```\n\n### Dependencies\n\nTo use TA-Lib for python, you need to have the\n[TA-Lib](http://ta-lib.org/hdr_dw.html) already installed. You should\nprobably follow their installation directions for your platform, but some\nsuggestions are included below for reference.\n\n> Some Conda Forge users have reported success installing the underlying TA-Lib C\n> library using [the libta-lib package](https://anaconda.org/conda-forge/libta-lib):\n>\n> ``$ conda install -c conda-forge libta-lib``\n\n##### Mac OS X\n\nYou can simply install using Homebrew:\n\n```\n$ brew install ta-lib\n```\n\nIf you are using Apple Silicon, such as the M1 processors, and building mixed\narchitecture Homebrew projects, you might want to make sure it's being built\nfor your architecture:\n\n```\n$ arch -arm64 brew install ta-lib\n```\n\nAnd perhaps you can set these before installing with ``pip``:\n\n```\n$ export TA_INCLUDE_PATH=\"$(brew --prefix ta-lib)/include\"\n$ export TA_LIBRARY_PATH=\"$(brew --prefix ta-lib)/lib\"\n```\n\nYou might also find this helpful, particularly if you have tried several\ndifferent installations without success:\n\n```\n$ your-arm64-python -m pip install --no-cache-dir ta-lib\n```\n\n##### Windows\n\nDownload [ta-lib-0.4.0-msvc.zip](https://sourceforge.net/projects/ta-lib/files/ta-lib/0.4.0/ta-lib-0.4.0-msvc.zip/download)\nand unzip to ``C:\\ta-lib``.\n\n> This is a 32-bit binary release. If you want to use 64-bit Python, you will\n> need to build a 64-bit version of the library. Some unofficial instructions\n> for building on 64-bit Windows 10 or Windows 11, here for reference:\n>\n> 1. Download and Unzip ``ta-lib-0.4.0-msvc.zip``\n> 2. Move the Unzipped Folder ``ta-lib`` to ``C:\\``\n> 3. Download and Install Visual Studio Community (2015 or later)\n> * Remember to Select ``[Visual C++]`` Feature\n> 4. Build TA-Lib Library\n> * From Windows Start Menu, Start ``[VS2015 x64 Native Tools Command\n> Prompt]``\n> * Move to ``C:\\ta-lib\\c\\make\\cdr\\win32\\msvc``\n> * Build the Library ``nmake``\n\nYou might also try these unofficial windows binary wheels for both 32-bit\nand 64-bit:\n\nhttps://github.com/cgohlke/talib-build/\n\n##### Linux\n\nDownload\n[ta-lib-0.4.0-src.tar.gz](https://sourceforge.net/projects/ta-lib/files/ta-lib/0.4.0/ta-lib-0.4.0-src.tar.gz/download)\nand:\n\n```\n$ tar -xzf ta-lib-0.4.0-src.tar.gz\n$ cd ta-lib/\n$ ./configure --prefix=/usr\n$ make\n$ sudo make install\n```\n\n> If you build ``TA-Lib`` using ``make -jX`` it will fail but that's OK!\n> Simply rerun ``make -jX`` followed by ``[sudo] make install``.\n\nNote: if your directory path includes spaces, the installation will probably\nfail with ``No such file or directory`` errors.\n\n### Troubleshooting\n\nIf you get a warning that looks like this:\n\n```\nsetup.py:79: UserWarning: Cannot find ta-lib library, installation may fail.\nwarnings.warn('Cannot find ta-lib library, installation may fail.')\n```\n\nThis typically means ``setup.py`` can't find the underlying ``TA-Lib``\nlibrary, a dependency which needs to be installed.\n\n---\n\nIf you installed the underlying ``TA-Lib`` library with a custom prefix\n(e.g., with ``./configure --prefix=$PREFIX``), then when you go to install\nthis python wrapper you can specify additional search paths to find the\nlibrary and include files for the underlying ``TA-Lib`` library using the\n``TA_LIBRARY_PATH`` and ``TA_INCLUDE_PATH`` environment variables:\n\n```sh\n$ export TA_LIBRARY_PATH=$PREFIX/lib\n$ export TA_INCLUDE_PATH=$PREFIX/include\n$ python setup.py install # or pip install ta-lib\n```\n\n---\n\nSometimes installation will produce build errors like this:\n\n```\ntalib/_ta_lib.c:601:10: fatal error: ta-lib/ta_defs.h: No such file or directory\n 601 | #include \"ta-lib/ta_defs.h\"\n | ^~~~~~~~~~~~~~~~~~\ncompilation terminated.\n```\n\nor:\n\n```\ncommon.obj : error LNK2001: unresolved external symbol TA_SetUnstablePeriod\ncommon.obj : error LNK2001: unresolved external symbol TA_Shutdown\ncommon.obj : error LNK2001: unresolved external symbol TA_Initialize\ncommon.obj : error LNK2001: unresolved external symbol TA_GetUnstablePeriod\ncommon.obj : error LNK2001: unresolved external symbol TA_GetVersionString\n```\n\nThis typically means that it can't find the underlying ``TA-Lib`` library, a\ndependency which needs to be installed. On Windows, this could be caused by\ninstalling the 32-bit binary distribution of the underlying ``TA-Lib`` library,\nbut trying to use it with 64-bit Python.\n\n---\n\nSometimes installation will fail with errors like this:\n\n```\ntalib/common.c:8:22: fatal error: pyconfig.h: No such file or directory\n #include \"pyconfig.h\"\n ^\ncompilation terminated.\nerror: command 'x86_64-linux-gnu-gcc' failed with exit status 1\n```\n\nThis typically means that you need the Python headers, and should run\nsomething like:\n\n```\n$ sudo apt-get install python3-dev\n```\n\n---\n\nSometimes building the underlying ``TA-Lib`` library has errors running\n``make`` that look like this:\n\n```\n../libtool: line 1717: cd: .libs/libta_lib.lax/libta_abstract.a: No such file or directory\nmake[2]: *** [libta_lib.la] Error 1\nmake[1]: *** [all-recursive] Error 1\nmake: *** [all-recursive] Error 1\n```\n\nThis might mean that the directory path to the underlying ``TA-Lib`` library\nhas spaces in the directory names. Try putting it in a path that does not have\nany spaces and trying again.\n\n---\n\nSometimes you might get this error running ``setup.py``:\n\n```\n/usr/include/limits.h:26:10: fatal error: bits/libc-header-start.h: No such file or directory\n#include <bits/libc-header-start.h>\n ^~~~~~~~~~~~~~~~~~~~~~~~~~\n```\n\nThis is likely an issue with trying to compile for 32-bit platform but\nwithout the appropriate headers. You might find some success looking at the\nfirst answer to [this question](https://stackoverflow.com/questions/54082459/fatal-error-bits-libc-header-start-h-no-such-file-or-directory-while-compili).\n\n---\n\nIf you get an error on macOS like this:\n\n```\ncode signature in <141BC883-189B-322C-AE90-CBF6B5206F67>\n'python3.9/site-packages/talib/_ta_lib.cpython-39-darwin.so' not valid for\nuse in process: Trying to load an unsigned library)\n```\n\nYou might look at [this question](https://stackoverflow.com/questions/69610572/how-can-i-solve-the-below-error-while-importing-nltk-package)\nand use ``xcrun codesign`` to fix it.\n\n---\n\nIf you wonder why ``STOCHRSI`` gives you different results than you expect,\nprobably you want ``STOCH`` applied to ``RSI``, which is a little different\nthan the ``STOCHRSI`` which is ``STOCHF`` applied to ``RSI``:\n\n```python\n>>> import talib\n>>> import numpy as np\n>>> c = np.random.randn(100)\n\n# this is the library function\n>>> k, d = talib.STOCHRSI(c)\n\n# this produces the same result, calling STOCHF\n>>> rsi = talib.RSI(c)\n>>> k, d = talib.STOCHF(rsi, rsi, rsi)\n\n# you might want this instead, calling STOCH\n>>> rsi = talib.RSI(c)\n>>> k, d = talib.STOCH(rsi, rsi, rsi)\n```\n\n---\n\nIf the build appears to hang, you might be running on a VM with not enough\nmemory -- try 1 GB or 2 GB.\n\n---\n\nIf you get \"permission denied\" errors such as this, you might need to give\nyour user access to the location where the underlying TA-Lib C library is\ninstalled -- or install it to a user-accessible location.\n\n```\ntalib/_ta_lib.c:747:28: fatal error: /usr/include/ta-lib/ta_defs.h: Permission denied\n #include \"ta-lib/ta-defs.h\"\n ^\ncompilation terminated\nerror: command 'gcc' failed with exit status 1\n```\n\n---\n\nIf you're having trouble compiling the underlying TA-Lib C library on ARM64,\nyou might need to configure it with an explicit build type before running\n``make`` and ``make install``, for example:\n\n```\n$ ./configure --build=aarch64-unknown-linux-gnu\n```\n\nThis is caused by old ``config.guess`` file, so another way to solve this is\nto copy a newer version of config.guess into the underyling TA-Lib C library\nsources:\n\n```\n$ cp /usr/share/automake-1.16/config.guess /path/to/extracted/ta-lib/config.guess\n```\n\nAnd then re-run configure:\n\n```\n$ ./configure\n```\n\n## Function API\n\nSimilar to TA-Lib, the Function API provides a lightweight wrapper of the\nexposed TA-Lib indicators.\n\nEach function returns an output array and have default values for their\nparameters, unless specified as keyword arguments. Typically, these functions\nwill have an initial \"lookback\" period (a required number of observations\nbefore an output is generated) set to ``NaN``.\n\nFor convenience, the Function API supports both ``numpy.ndarray`` and\n``pandas.Series`` and ``polars.Series`` inputs.\n\nAll of the following examples use the Function API:\n\n```python\nimport numpy as np\nimport talib\n\nclose = np.random.random(100)\n```\n\nCalculate a simple moving average of the close prices:\n\n```python\noutput = talib.SMA(close)\n```\n\nCalculating bollinger bands, with triple exponential moving average:\n\n```python\nfrom talib import MA_Type\n\nupper, middle, lower = talib.BBANDS(close, matype=MA_Type.T3)\n```\n\nCalculating momentum of the close prices, with a time period of 5:\n\n```python\noutput = talib.MOM(close, timeperiod=5)\n```\n\n##### NaN's\n\nThe underlying TA-Lib C library handles NaN's in a sometimes surprising manner\nby typically propagating NaN's to the end of the output, for example:\n\n```python\n>>> c = np.array([1.0, 2.0, 3.0, np.nan, 4.0, 5.0, 6.0])\n\n>>> talib.SMA(c, 3)\narray([nan, nan, 2., nan, nan, nan, nan])\n```\n\nYou can compare that to a Pandas rolling mean, where their approach is to\noutput NaN until enough \"lookback\" values are observed to generate new outputs:\n\n```python\n>>> c = pandas.Series([1.0, 2.0, 3.0, np.nan, 4.0, 5.0, 6.0])\n\n>>> c.rolling(3).mean()\n0 NaN\n1 NaN\n2 2.0\n3 NaN\n4 NaN\n5 NaN\n6 5.0\ndtype: float64\n```\n\n## Abstract API\n\nIf you're already familiar with using the function API, you should feel right\nat home using the Abstract API.\n\nEvery function takes a collection of named inputs, either a ``dict`` of\n``numpy.ndarray`` or ``pandas.Series`` or ``polars.Series``, or a\n``pandas.DataFrame`` or ``polars.DataFrame``. If a ``pandas.DataFrame`` or\n``polars.DataFrame`` is provided, the output is returned as the same type\nwith named output columns.\n\nFor example, inputs could be provided for the typical \"OHLCV\" data:\n\n```python\nimport numpy as np\n\n# note that all ndarrays must be the same length!\ninputs = {\n 'open': np.random.random(100),\n 'high': np.random.random(100),\n 'low': np.random.random(100),\n 'close': np.random.random(100),\n 'volume': np.random.random(100)\n}\n```\n\nFunctions can either be imported directly or instantiated by name:\n\n```python\nfrom talib import abstract\n\n# directly\nSMA = abstract.SMA\n\n# or by name\nSMA = abstract.Function('sma')\n```\n\nFrom there, calling functions is basically the same as the function API:\n\n```python\nfrom talib.abstract import *\n\n# uses close prices (default)\noutput = SMA(inputs, timeperiod=25)\n\n# uses open prices\noutput = SMA(inputs, timeperiod=25, price='open')\n\n# uses close prices (default)\nupper, middle, lower = BBANDS(inputs, 20, 2.0, 2.0)\n\n# uses high, low, close (default)\nslowk, slowd = STOCH(inputs, 5, 3, 0, 3, 0) # uses high, low, close by default\n\n# uses high, low, open instead\nslowk, slowd = STOCH(inputs, 5, 3, 0, 3, 0, prices=['high', 'low', 'open'])\n```\n\n## Streaming API\n\nAn experimental Streaming API was added that allows users to compute the latest\nvalue of an indicator. This can be faster than using the Function API, for\nexample in an application that receives streaming data, and wants to know just\nthe most recent updated indicator value.\n\n```python\nimport talib\nfrom talib import stream\n\nclose = np.random.random(100)\n\n# the Function API\noutput = talib.SMA(close)\n\n# the Streaming API\nlatest = stream.SMA(close)\n\n# the latest value is the same as the last output value\nassert (output[-1] - latest) < 0.00001\n```\n\n## Supported Indicators and Functions\n\nWe can show all the TA functions supported by TA-Lib, either as a ``list`` or\nas a ``dict`` sorted by group (e.g. \"Overlap Studies\", \"Momentum Indicators\",\netc):\n\n```python\nimport talib\n\n# list of functions\nfor name in talib.get_functions():\n print(name)\n\n# dict of functions by group\nfor group, names in talib.get_function_groups().items():\n print(group)\n for name in names:\n print(f\" {name}\")\n```\n\n### Indicator Groups\n\n* Overlap Studies\n* Momentum Indicators\n* Volume Indicators\n* Volatility Indicators\n* Price Transform\n* Cycle Indicators\n* Pattern Recognition\n\n##### Overlap Studies\n```\nBBANDS Bollinger Bands\nDEMA Double Exponential Moving Average\nEMA Exponential Moving Average\nHT_TRENDLINE Hilbert Transform - Instantaneous Trendline\nKAMA Kaufman Adaptive Moving Average\nMA Moving average\nMAMA MESA Adaptive Moving Average\nMAVP Moving average with variable period\nMIDPOINT MidPoint over period\nMIDPRICE Midpoint Price over period\nSAR Parabolic SAR\nSAREXT Parabolic SAR - Extended\nSMA Simple Moving Average\nT3 Triple Exponential Moving Average (T3)\nTEMA Triple Exponential Moving Average\nTRIMA Triangular Moving Average\nWMA Weighted Moving Average\n```\n\n##### Momentum Indicators\n```\nADX Average Directional Movement Index\nADXR Average Directional Movement Index Rating\nAPO Absolute Price Oscillator\nAROON Aroon\nAROONOSC Aroon Oscillator\nBOP Balance Of Power\nCCI Commodity Channel Index\nCMO Chande Momentum Oscillator\nDX Directional Movement Index\nMACD Moving Average Convergence/Divergence\nMACDEXT MACD with controllable MA type\nMACDFIX Moving Average Convergence/Divergence Fix 12/26\nMFI Money Flow Index\nMINUS_DI Minus Directional Indicator\nMINUS_DM Minus Directional Movement\nMOM Momentum\nPLUS_DI Plus Directional Indicator\nPLUS_DM Plus Directional Movement\nPPO Percentage Price Oscillator\nROC Rate of change : ((price/prevPrice)-1)*100\nROCP Rate of change Percentage: (price-prevPrice)/prevPrice\nROCR Rate of change ratio: (price/prevPrice)\nROCR100 Rate of change ratio 100 scale: (price/prevPrice)*100\nRSI Relative Strength Index\nSTOCH Stochastic\nSTOCHF Stochastic Fast\nSTOCHRSI Stochastic Relative Strength Index\nTRIX 1-day Rate-Of-Change (ROC) of a Triple Smooth EMA\nULTOSC Ultimate Oscillator\nWILLR Williams' %R\n```\n\n##### Volume Indicators\n```\nAD Chaikin A/D Line\nADOSC Chaikin A/D Oscillator\nOBV On Balance Volume\n```\n\n##### Cycle Indicators\n```\nHT_DCPERIOD Hilbert Transform - Dominant Cycle Period\nHT_DCPHASE Hilbert Transform - Dominant Cycle Phase\nHT_PHASOR Hilbert Transform - Phasor Components\nHT_SINE Hilbert Transform - SineWave\nHT_TRENDMODE Hilbert Transform - Trend vs Cycle Mode\n```\n\n##### Price Transform\n```\nAVGPRICE Average Price\nMEDPRICE Median Price\nTYPPRICE Typical Price\nWCLPRICE Weighted Close Price\n```\n\n##### Volatility Indicators\n```\nATR Average True Range\nNATR Normalized Average True Range\nTRANGE True Range\n```\n\n##### Pattern Recognition\n```\nCDL2CROWS Two Crows\nCDL3BLACKCROWS Three Black Crows\nCDL3INSIDE Three Inside Up/Down\nCDL3LINESTRIKE Three-Line Strike\nCDL3OUTSIDE Three Outside Up/Down\nCDL3STARSINSOUTH Three Stars In The South\nCDL3WHITESOLDIERS Three Advancing White Soldiers\nCDLABANDONEDBABY Abandoned Baby\nCDLADVANCEBLOCK Advance Block\nCDLBELTHOLD Belt-hold\nCDLBREAKAWAY Breakaway\nCDLCLOSINGMARUBOZU Closing Marubozu\nCDLCONCEALBABYSWALL Concealing Baby Swallow\nCDLCOUNTERATTACK Counterattack\nCDLDARKCLOUDCOVER Dark Cloud Cover\nCDLDOJI Doji\nCDLDOJISTAR Doji Star\nCDLDRAGONFLYDOJI Dragonfly Doji\nCDLENGULFING Engulfing Pattern\nCDLEVENINGDOJISTAR Evening Doji Star\nCDLEVENINGSTAR Evening Star\nCDLGAPSIDESIDEWHITE Up/Down-gap side-by-side white lines\nCDLGRAVESTONEDOJI Gravestone Doji\nCDLHAMMER Hammer\nCDLHANGINGMAN Hanging Man\nCDLHARAMI Harami Pattern\nCDLHARAMICROSS Harami Cross Pattern\nCDLHIGHWAVE High-Wave Candle\nCDLHIKKAKE Hikkake Pattern\nCDLHIKKAKEMOD Modified Hikkake Pattern\nCDLHOMINGPIGEON Homing Pigeon\nCDLIDENTICAL3CROWS Identical Three Crows\nCDLINNECK In-Neck Pattern\nCDLINVERTEDHAMMER Inverted Hammer\nCDLKICKING Kicking\nCDLKICKINGBYLENGTH Kicking - bull/bear determined by the longer marubozu\nCDLLADDERBOTTOM Ladder Bottom\nCDLLONGLEGGEDDOJI Long Legged Doji\nCDLLONGLINE Long Line Candle\nCDLMARUBOZU Marubozu\nCDLMATCHINGLOW Matching Low\nCDLMATHOLD Mat Hold\nCDLMORNINGDOJISTAR Morning Doji Star\nCDLMORNINGSTAR Morning Star\nCDLONNECK On-Neck Pattern\nCDLPIERCING Piercing Pattern\nCDLRICKSHAWMAN Rickshaw Man\nCDLRISEFALL3METHODS Rising/Falling Three Methods\nCDLSEPARATINGLINES Separating Lines\nCDLSHOOTINGSTAR Shooting Star\nCDLSHORTLINE Short Line Candle\nCDLSPINNINGTOP Spinning Top\nCDLSTALLEDPATTERN Stalled Pattern\nCDLSTICKSANDWICH Stick Sandwich\nCDLTAKURI Takuri (Dragonfly Doji with very long lower shadow)\nCDLTASUKIGAP Tasuki Gap\nCDLTHRUSTING Thrusting Pattern\nCDLTRISTAR Tristar Pattern\nCDLUNIQUE3RIVER Unique 3 River\nCDLUPSIDEGAP2CROWS Upside Gap Two Crows\nCDLXSIDEGAP3METHODS Upside/Downside Gap Three Methods\n```\n\n##### Statistic Functions\n```\nBETA Beta\nCORREL Pearson's Correlation Coefficient (r)\nLINEARREG Linear Regression\nLINEARREG_ANGLE Linear Regression Angle\nLINEARREG_INTERCEPT Linear Regression Intercept\nLINEARREG_SLOPE Linear Regression Slope\nSTDDEV Standard Deviation\nTSF Time Series Forecast\nVAR Variance\n```\n",
"bugtrack_url": null,
"license": "BSD",
"summary": "Python wrapper for TA-Lib",
"version": "0.4.32",
"project_urls": {
"Download": "https://github.com/ta-lib/ta-lib-python/releases",
"Homepage": "http://github.com/ta-lib/ta-lib-python"
},
"split_keywords": [],
"urls": [
{
"comment_text": "",
"digests": {
"blake2b_256": "37f5749d1b1e4d2eb22b37da5c96529b01f8c4daaf9e30428166cd3185832500",
"md5": "f9a6aebaec76e9f3a4fdbc4dc1e707b3",
"sha256": "fb74c323217bead847a045c97aa17bfd147aef17e20a75857ea0f8f7ee7cdaa0"
},
"downloads": -1,
"filename": "TA-Lib-0.4.32.tar.gz",
"has_sig": false,
"md5_digest": "f9a6aebaec76e9f3a4fdbc4dc1e707b3",
"packagetype": "sdist",
"python_version": "source",
"requires_python": null,
"size": 368477,
"upload_time": "2024-06-30T15:59:03",
"upload_time_iso_8601": "2024-06-30T15:59:03.296624Z",
"url": "https://files.pythonhosted.org/packages/37/f5/749d1b1e4d2eb22b37da5c96529b01f8c4daaf9e30428166cd3185832500/TA-Lib-0.4.32.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2024-06-30 15:59:03",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "ta-lib",
"github_project": "ta-lib-python",
"travis_ci": false,
"coveralls": false,
"github_actions": true,
"requirements": [],
"lcname": "ta-lib"
}
JSON
