diff --git a/.gitignore b/.gitignore index 24e0eac..b69f012 100644 --- a/.gitignore +++ b/.gitignore @@ -124,6 +124,7 @@ reqs.txt requirements.txt driver.py qd.py +tdseq.py # Local package installs ta-lib/ diff --git a/README.md b/README.md index cd33b0d..707912b 100644 --- a/README.md +++ b/README.md @@ -11,10 +11,11 @@ Pandas TA - A Technical Analysis Library in Python 3 [![PyPi Version](https://img.shields.io/pypi/v/pandas_ta.svg)](https://pypi.org/project/pandas_ta/) [![Package Status](https://img.shields.io/pypi/status/pandas_ta.svg)](https://pypi.org/project/pandas_ta/) [![Downloads](https://img.shields.io/pypi/dm/pandas_ta.svg?style=flat)](https://pypistats.org/packages/pandas_ta) +[![Contributors](https://img.shields.io/badge/contributors-19-orange.svg?style=flat)](#contributors-) ![Example Chart](/images/TA_Chart.png) -_Pandas Technical Analysis_ (**Pandas TA**) is an easy to use library that leverages the Pandas library with more than 120 Indicators and Utility functions. Many commonly used indicators are included, such as: _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_**. +_Pandas Technical Analysis_ (**Pandas TA**) is an easy to use library that leverages the Pandas library with more than 130 Indicators and Utility functions. Many commonly used indicators are included, such as: _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_**.
@@ -33,16 +34,18 @@ _Pandas Technical Analysis_ (**Pandas TA**) is an easy to use library that lever * [Pandas TA Strategies](#pandas-ta-strategies) * [Types of Strategies](#types-of-strategies) * [DataFrame Properties](#dataframe-properties) +* [DataFrame Methods](#dataframe-methods) * [Indicators by Category](#indicators-by-category) * [Candles](#candles-3) - * [Momentum](#momentum-35) - * [Overlap](#overlap-29) + * [Cycles](#cycles-1) + * [Momentum](#momentum-37) + * [Overlap](#overlap-31) * [Performance](#performance-4) * [Statistics](#statistics-9) * [Trend](#trend-15) * [Utility](#utility-5) * [Volatility](#volatility-13) - * [Volume](#volume-13) + * [Volume](#volume-14) * [Performance Metrics](#performance-metrics) * [Changes](#changes) * [General](#general) @@ -59,13 +62,14 @@ _Pandas Technical Analysis_ (**Pandas TA**) is an easy to use library that lever # **Features** -* Has 120+ indicators and utility functions. +* Has 130+ indicators and utility functions. * Indicators are tightly correlated with the de facto [TA Lib](https://mrjbq7.github.io/ta-lib/) if they share common indicators. * Have the need for speed? By using the DataFrame _strategy_ method, you get **multiprocessing** for free! * Easily add _prefixes_ or _suffixes_ or both to columns names. Useful for Custom Chained Strategies. * Example Jupyter Notebooks under the [examples](https://github.com/twopirllc/pandas-ta/tree/master/examples) directory, including how to create Custom Strategies using the new [__Strategy__ Class](https://github.com/twopirllc/pandas-ta/tree/master/examples/PandaTA_Strategy_Examples.ipynb) * Potential Data Leaks: **ichimoku** and **dpo**. See indicator list below for details. * **UNDER DEVELOPMENT:** Performance Metrics +* **UNDER DEVELOPMENT:** Easy Downloading of _ohlcv_ data using [yfinance](https://github.com/ranaroussi/yfinance). See ```help(ta.ticker)``` and ```help(ta.yf)```
@@ -74,14 +78,14 @@ _Pandas Technical Analysis_ (**Pandas TA**) is an easy to use library that lever Stable ------ -The ```pip``` version is the last most stable release. +The ```pip``` version is the last most stable release. Version: *0.2.45b* ```sh $ pip install pandas_ta ``` Latest Version -------------- -Best choice! +Best choice! Version: *0.2.62b* ```sh $ pip install -U git+https://github.com/twopirllc/pandas-ta ``` @@ -100,8 +104,12 @@ $ pip install -U git+https://github.com/twopirllc/pandas-ta.git@development import pandas as pd import pandas_ta as ta +df = pd.DataFrame() # Empty DataFrame + # Load data df = pd.read_csv("path/to/symbol.csv", sep=",") +# OR if you have yfinance installed +df = df.ta.ticker("aapl") # VWAP requires the DataFrame index to be a DatetimeIndex. # Replace "datetime" with the appropriate column from your DataFrame @@ -136,8 +144,8 @@ help(df.ta) # List of all indicators df.ta.indicators() -# Help about the log_return indicator -help(ta.log_return) +# Help about an indicator such as bbands +help(ta.bbands) ```
@@ -175,7 +183,7 @@ Thanks for using **Pandas TA**! _Thank you for your contributions!_ -[alexonab](https://github.com/alexonab) | [allahyarzadeh](https://github.com/allahyarzadeh) | [codesutras](https://github.com/codesutras) | [daikts](https://github.com/daikts) | [DrPaprikaa](https://github.com/DrPaprikaa) | [FGU1](https://github.com/FGU1) | [lluissalord](https://github.com/lluissalord) | [maxdignan](https://github.com/maxdignan) | [NkosenhleDuma](https://github.com/NkosenhleDuma) | [pbrumblay](https://github.com/pbrumblay) | [RajeshDhalange](https://github.com/RajeshDhalange) | [rengel8](https://github.com/rengel8) | [rluong003](https://github.com/rluong003) | [SoftDevDanial](https://github.com/SoftDevDanial) | [tg12](https://github.com/tg12) | [twrobel](https://github.com/twrobel) | [whubsch](https://github.com/whubsch) | [YuvalWein](https://github.com/YuvalWein) +[alexonab](https://github.com/alexonab) | [allahyarzadeh](https://github.com/allahyarzadeh) | [codesutras](https://github.com/codesutras) | [DrPaprikaa](https://github.com/DrPaprikaa) | [daikts](https://github.com/daikts) | [dorren](https://github.com/dorren) | [edwardwang1](https://github.com/edwardwang1) | [ffhirata](https://github.com/ffhirata) | [FGU1](https://github.com/FGU1) | [lluissalord](https://github.com/lluissalord) | [M6stafa](https://github.com/M6stafa) | [maxdignan](https://github.com/maxdignan) | [moritzgun](https://github.com/moritzgun) | [NkosenhleDuma](https://github.com/NkosenhleDuma) | [pbrumblay](https://github.com/pbrumblay) | [RajeshDhalange](https://github.com/RajeshDhalange) | [rengel8](https://github.com/rengel8) | [rluong003](https://github.com/rluong003) | [SoftDevDanial](https://github.com/SoftDevDanial) | [tg12](https://github.com/tg12) | [twrobel](https://github.com/twrobel) | [whubsch](https://github.com/whubsch) | [witokondoria](https://github.com/witokondoria) | [wouldayajustlookatit](https://github.com/wouldayajustlookatit) | [YuvalWein](https://github.com/YuvalWein)
@@ -341,6 +349,7 @@ df.ta.strategy(verbose=True) df.ta.strategy(timed=True) # Choose the number of cores to use. Default is all available cores. +# For no multiprocessing, set this value to 0. df.ta.cores = 4 # Maybe you do not want certain indicators. @@ -405,6 +414,9 @@ df.ta.categories # Defaults to the number of cpus you have. df.ta.cores = 4 +# Set the number of cores to 0 for no multiprocessing. +df.ta.cores = 0 + # Returns the number of cores you set or your default number of cpus. df.ta.cores ``` @@ -418,6 +430,24 @@ df.ta.cores df.ta.datetime_ordered ``` +## **exchange** + +```python +# Sets the Exchange to use when calculating the last_run property. Default: "NYSE" +df.ta.exchange + +# Set the Exchange to use. +# Available Exchanges: "ASX", "BMF", "DIFX", "FWB", "HKE", "JSE", "LSE", "NSE", "NYSE", "NZSX", "RTS", "SGX", "SSE", "TSE", "TSX" +df.ta.exchange = "LSE" +``` + +## **last_run** + +```python +# Returns the time Pandas TA was last run as a string. +df.ta.last_run +``` + ## **reverse** ```python @@ -442,6 +472,85 @@ bothhl2 = df.ta.hl2(prefix="pre", suffix="post") print(bothhl2.name) # "pre_HL2_post" ``` +## **time_range** + +```python +# Returns the time range of the DataFrame as a float. +# By default, it returns the time in "years" +df.ta.time_range + +# Available time_ranges include: "years", "months", "weeks", "days", "hours", "minutes". "seconds" +df.ta.time_range = "days" +df.ta.time_range # prints DataFrame time in "days" as float +``` + +## **to_utc** + +```python +# Sets the DataFrame index to UTC format. +df.ta.to_utc +``` + +

+ + +# **DataFrame Methods** + +## **constants** + +```python +import numpy as np + +# Add constant '1' to the DataFrame +df.ta.constants(True, [1]) +# Remove constant '1' to the DataFrame +df.ta.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.ta.constants(True, chart_lines) +# Removing some constants from the DataFrame +df.ta.constants(False, np.array([-60, -40, 40, 60])) +``` + +## **indicators** + +```python +# Prints the indicators and utility functions +df.ta.indicators() + +# Returns a list of indicators and utility functions +ind_list = df.ta.indicators(as_list=True) + +# Prints the indicators and utility functions that are not in the excluded list +df.ta.indicators(exclude=["cg", "pgo", "ui"]) +# Returns a list of the indicators and utility functions that are not in the excluded list +smaller_list = df.ta.indicators(exclude=["cg", "pgo", "ui"], as_list=True) +``` + +## **ticker** + +```python +# 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.ta.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.ta.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.ta.ticker("aapl", period="1y", interval="1wk") # Gets this past year in weeks +df = df.ta.ticker("aapl", period="1mo", interval="1h") # Gets this past month in hours + +# BUT WAIT!! THERE'S MORE!! +help(ta.yf) +``` +

# **Indicators** (_by Category_) @@ -450,8 +559,15 @@ print(bothhl2.name) # "pre_HL2_post" * _Doji_: **cdl_doji** * _Inside Bar_: **cdl_inside** * _Heikin-Ashi_: **ha** +
-### **Momentum** (36) + +### **Cycles** (1) + +* _Even Better Sinewave_: **ebsw** +
+ +### **Momentum** (37) * _Awesome Oscillator_: **ao** * _Absolute Price Oscillator_: **apo** @@ -486,6 +602,8 @@ print(bothhl2.name) # "pre_HL2_post" * Default is John Carter's. Enable Lazybear's with ```lazybear=True``` * _Stochastic Oscillator_: **stoch** * _Stochastic RSI_: **stochrsi** +* _TD Sequential_: **td_seq** + * Excluded from ```df.ta.strategy()```. * _Trix_: **trix** * _True strength index_: **tsi** * _Ultimate Oscillator_: **uo** @@ -495,9 +613,11 @@ print(bothhl2.name) # "pre_HL2_post" | _Moving Average Convergence Divergence_ (MACD) | |:--------:| | ![Example MACD](/images/SPY_MACD.png) | +
-### **Overlap** (30) +### **Overlap** (31) +* _Arnaud Legoux Moving Average_: **alma** * _Double Exponential Moving Average_: **dema** * _Exponential Moving Average_: **ema** * _Fibonacci's Weighted Moving Average_: **fwma** @@ -506,6 +626,7 @@ print(bothhl2.name) # "pre_HL2_post" * _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** * Use: help(ta.ichimoku). Returns two DataFrames. * Drop the Chikou Span Column, the final column of the first resultant DataFrame, remove potential data leak. @@ -536,6 +657,7 @@ print(bothhl2.name) # "pre_HL2_post" | _Simple Moving Averages_ (SMA) and _Bollinger Bands_ (BBANDS) | |:--------:| | ![Example Chart](/images/TA_Chart.png) | +
### **Performance** (4) @@ -550,7 +672,7 @@ Use parameter: cumulative=**True** for cumulative results. | _Percent Return_ (Cumulative) with _Simple Moving Average_ (SMA) | |:--------:| | ![Example Cumulative Percent Return](/images/SPY_CumulativePercentReturn.png) | - +
### **Statistics** (9) @@ -567,10 +689,12 @@ Use parameter: cumulative=**True** for cumulative results. | _Z Score_ | |:--------:| | ![Example Z Score](/images/SPY_ZScore.png) | +
### **Trend** (15) * _Average Directional Movement Index_: **adx** + * Also includes **dmp** and **dmn** in the resultant DataFrame. * _Archer Moving Averages Trends_: **amat** * _Aroon & Aroon Oscillator_: **aroon** * _Choppiness Index_: **chop** @@ -643,7 +767,7 @@ Use parameter: cumulative=**True** for cumulative results.

-# **Performance Metrics** (BETA) +# **Performance Metrics**   _BETA_ _Performance Metrics_ are a **new** addition to the package and consequentially are likely unreliable. **Use at your own risk.** These metrics return a _float_ and are _not_ part of the _DataFrame_ Extension. They are called the Standard way. For Example: ```python @@ -673,31 +797,21 @@ result = ta.cagr(df.close) * **Moving Average Choices**: dema, ema, fwma, hma, linreg, midpoint, pwma, rma, sinwma, sma, swma, t3, tema, trima, vidya, wma, zlma. * An _experimental_ and independent __Watchlist__ Class located in the [Examples](https://github.com/twopirllc/pandas-ta/tree/master/examples/watchlist.py) Directory that can be used in conjunction with the new __Strategy__ Class. * _Linear Regression_ (**linear_regression**) is a new utility method for Simple Linear Regression using _Numpy_ or _Scikit Learn_'s implementation. -* Added utility/convience function, ```to_utc```, to convert the DataFrame index to UTC. See: ```help(ta.to_utc)``` +* Added utility/convience function, ```to_utc```, to convert the DataFrame index to UTC. See: ```help(ta.to_utc)``` **Now** as a Pandas TA DataFrame Property to easily convert the DataFrame index to UTC.
-## **Breaking Indicators** -* _Bollinger Bands_ (**bbands**): New column 'bandwidth' appended to the returning DataFrame. See: ```help(ta.bbands)``` -* _Volume Weighted Average Price_ (**vwap**): **Requires** the DataFrame index to be a DatetimeIndex. - - ## **New Indicators** -* _Drawdown_ (**drawdown**) shows the peak-to-trough decline during a specific period for an investment, +* _Arnaud Legoux Moving Average_ (**alma**) uses the curve of the Normal (Gauss) distribution to allow regulating the smoothness and high sensitivity of the indicator. See: ```help(ta.alma)``` trading account, or fund. See: ```help(ta.drawdown)``` -* _Gann High-Low Activator_ (**hilo**) was created by Robert Krausz in a 1998. See: ```help(ta.hilo)``` -* _McGinley Dynamic_ (**mcgd**) is an overlap indicator developed by John R. McGinley, a Certified Market Technician. See: ```help(ta.mcgd)``` -* _Price Volume Rank_ (**pvr**) was created by Anthony J. Macek. See: ```help(ta.pvr)``` -* _Quantitative Qualitative Estimation_ (**qqe**) is like SuperTrend for a Smoothed RSI. See: ```help(ta.qqe)``` -article in the June, 1994 issue of Technical Analysis of Stocks & Commodities Magazine. See: ```help(ta.pvr)``` -* _Relative Strength Xtra_ (**rsx**) is based on the popular RSI indicator and inspired by the work Jurik Research. See: ```help(ta.rsx)``` -* _Ehler's Super Smoother Filter_ (**ssf**). Ehler's solution to reduce lag and remove aliasing noise compared to other common moving average indicators. See: ```help(ta.ssf)``` -* _Elder's Thermometer_ (**thermo**) measures price volatility. See: ```help(ta.thermo)``` -* _TTM Trend_ (**ttm_trend**) is a trend indicator inspired from John Carter's book "Mastering the Trade" issue of Stocks & Commodities Magazine. It is a moving average based trend indicator consisting of two different simple moving averages. See: ```help(ta.ttm_trend)``` -* _Variable Index Dynamic Average_ (**vidya**) is a popular Dynamic Moving Average created by Tushar Chande. See: ```help(ta.vidya)``` +* _Even Better Sinewave_ (**ebsw**) measures market cycles and uses a low pass filter to remove noise. See: ```help(ta.ebsw)``` +* _Tom DeMark's Sequential_ (**td_seq**) attempts to identify a price point where an uptrend or a downtrend exhausts itself and reverses. Currently exlcuded from ```df.ta.strategy()``` for performance reasons. See: ```help(ta.td_seq)``` +
## **Updated Indicators** +* _ADX_ (**adx**): Added ```mamode``` with default "**RMA**" and with the same ```mamode``` options as TradingView. See ```help(ta.adx)```. * _Average True Range_ (**atr**): The default ```mamode``` is now "**RMA**" and with the same ```mamode``` options as TradingView. See ```help(ta.atr)```. +* _Bollinger Bands_ (**bbands**): New argument ```ddoff``` to control the Degrees of Freedom. Default is 0. See ```help(ta.bbands)```. * _Decreasing_ (**decreasing**): New argument ```strict``` checks if the series is continuously decreasing over period ```length```. Default: ```False```. See ```help(ta.decreasing)```. * _Increasing_ (**increasing**): New argument ```strict``` checks if the series is continuously increasing over period ```length```. Default: ```False```. See ```help(ta.increasing)```. * _Trend Return_ (**trend_return**): Returns a DataFrame now instead of Series with pertinenet trade info for a _trend_. An example can be found in the [AI Example Notebook](https://github.com/twopirllc/pandas-ta/tree/master/examples/AIExample.ipynb). The notebook is still a work in progress and open to colloboration. @@ -706,8 +820,4 @@ article in the June, 1994 issue of Technical Analysis of Stocks & Commodities Ma
# **Sources** -* [Original TA-LIB](http://ta-lib.org/) -* [TradingView](http://www.tradingview.com) -* [Sierra Chart](https://search.sierrachart.com/?Query=indicators&submitted=true) -* [FM Labs](https://www.fmlabs.com/reference/default.htm) -* [User 42](https://user42.tuxfamily.org/chart/manual/index.html) +[Original TA-LIB](http://ta-lib.org/) | [TradingView](http://www.tradingview.com) | [Sierra Chart](https://search.sierrachart.com/?Query=indicators&submitted=true) | [MQL5](https://www.mql5.com) | [FM Labs](https://www.fmlabs.com/reference/default.htm) | [Pro Real Code](https://www.prorealcode.com/prorealtime-indicators) | [User 42](https://user42.tuxfamily.org/chart/manual/index.html) \ No newline at end of file diff --git a/examples/AIExample.ipynb b/examples/AIExample.ipynb index 4d3e178..f4f7576 100644 --- a/examples/AIExample.ipynb +++ b/examples/AIExample.ipynb @@ -43,10 +43,14 @@ "output_type": "stream", "text": [ "Populating the interactive namespace from numpy and matplotlib\n", - "Numpy v1.19.5\n", - "Pandas v1.2.0\n", - "mplfinance v0.12.7a4\n", - "Pandas TA v0.2.40b0\n" + "Numpy v1.20.1\n", + "Pandas v1.2.2\n", + "mplfinance v0.12.7a5\n", + "\n", + "Pandas TA v0.2.49b0\n", + "To install the Latest Version:\n", + "$ pip install -U git+https://github.com/twopirllc/pandas-ta\n", + "\n" ] } ], @@ -69,7 +73,7 @@ "print(f\"Numpy v{np.__version__}\")\n", "print(f\"Pandas v{pd.__version__}\")\n", "print(f\"mplfinance v{mpf.__version__}\")\n", - "print(f\"Pandas TA v{ta.version}\")\n", + "print(f\"\\nPandas TA v{ta.version}\\nTo install the Latest Version:\\n$ pip install -U git+https://github.com/twopirllc/pandas-ta\\n\")\n", "%matplotlib inline" ] }, @@ -109,22 +113,29 @@ "name": "stdout", "output_type": "stream", "text": [ - "[!] Loading All: SPY, QQQ, AAPL, TSLA\n", - "[i] Loaded['D']: SPY_D.csv\n", - "[i] Runtime: 360.4083 ms (0.3604 s)\n", - "[i] Loaded['D']: QQQ_D.csv\n", - "[i] Runtime: 388.5823 ms (0.3886 s)\n", - "[i] Loaded['D']: AAPL_D.csv\n", - "[i] Runtime: 351.0826 ms (0.3511 s)\n", - "[i] Loaded['D']: TSLA_D.csv\n", - "[i] Runtime: 350.7362 ms (0.3507 s)\n" + "[!] Loading All: SPY, QQQ, AAPL, TSLA, BTC-USD\n", + "[+] Downloading[yahoo]: SPY[D]\n", + "[+] Saving: /Users/kj/av_data/SPY_D.csv\n", + "[i] Runtime: 450.8733 ms (0.4509 s)\n", + "[+] Downloading[yahoo]: QQQ[D]\n", + "[+] Saving: /Users/kj/av_data/QQQ_D.csv\n", + "[i] Runtime: 438.7223 ms (0.4387 s)\n", + "[+] Downloading[yahoo]: AAPL[D]\n", + "[+] Saving: /Users/kj/av_data/AAPL_D.csv\n", + "[i] Runtime: 443.3815 ms (0.4434 s)\n", + "[+] Downloading[yahoo]: TSLA[D]\n", + "[+] Saving: /Users/kj/av_data/TSLA_D.csv\n", + "[i] Runtime: 446.6432 ms (0.4466 s)\n", + "[+] Downloading[yahoo]: BTC-USD[D]\n", + "[+] Saving: /Users/kj/av_data/BTC-USD_D.csv\n", + "[i] Runtime: 454.7926 ms (0.4548 s)\n" ] } ], "source": [ "tf = \"D\"\n", - "tickers = [\"SPY\", \"QQQ\", \"AAPL\", \"TSLA\"]\n", - "watch = Watchlist(tickers, tf=tf, timed=True)\n", + "tickers = [\"SPY\", \"QQQ\", \"AAPL\", \"TSLA\", \"BTC-USD\"]\n", + "watch = Watchlist(tickers, tf=tf, ds_name=\"yahoo\", timed=True)\n", "watch.strategy = ta.CommonStrategy\n", "watch.load(tickers, analyze=True, verbose=False)" ] @@ -145,8 +156,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "SPY (5265, 10)\n", - "Columns: open, high, low, close, volume, SMA_10, SMA_20, SMA_50, SMA_200, VOL_SMA_20\n" + "SPY (7086, 12)\n", + "Columns: open, high, low, close, volume, dividends, split, SMA_10, SMA_20, SMA_50, SMA_200, VOL_SMA_20\n" ] } ], @@ -206,6 +217,8 @@ " \n", " \n", " \n", + " dividends\n", + " split\n", " SMA_10\n", " SMA_20\n", " SMA_50\n", @@ -225,84 +238,96 @@ " \n", " \n", " \n", + " \n", + " \n", " \n", " \n", " \n", " \n", - " 2020-09-28\n", - " 331.181\n", - " 336.9395\n", - " 334.8642\n", - " 310.30500\n", - " 86281647.00\n", - " 330.408828\n", - " 334.010756\n", - " 331.721246\n", + " 2021-03-15\n", + " 0.000\n", + " 0\n", + " 385.812372\n", + " 386.472707\n", + " 382.382806\n", + " 346.504071\n", + " 100066335.0\n", + " 389.130999\n", + " 386.319421\n", + " 380.945454\n", " \n", " \n", - " 2020-09-29\n", - " 330.401\n", - " 336.0925\n", - " 335.0252\n", - " 310.38120\n", - " 85553267.55\n", - " 330.844644\n", - " 333.861596\n", - " 331.746687\n", + " 2021-03-16\n", + " 0.000\n", + " 0\n", + " 386.746310\n", + " 386.652617\n", + " 382.821967\n", + " 346.979575\n", + " 101165615.0\n", + " 390.350227\n", + " 387.073794\n", + " 381.481613\n", " \n", " \n", - " 2020-09-30\n", - " 330.008\n", - " 335.2070\n", - " 335.2228\n", - " 310.46905\n", - " 88007358.10\n", - " 331.743612\n", - " 333.955087\n", - " 331.869955\n", + " 2021-03-17\n", + " 0.000\n", + " 0\n", + " 388.325140\n", + " 386.895322\n", + " 383.389508\n", + " 347.455754\n", + " 103142185.0\n", + " 391.597540\n", + " 387.881916\n", + " 382.049516\n", " \n", " \n", - " 2020-10-01\n", - " 330.128\n", - " 334.1740\n", - " 335.4264\n", - " 310.55675\n", - " 88965293.60\n", - " 332.920587\n", - " 334.235534\n", - " 332.072702\n", + " 2021-03-18\n", + " 0.000\n", + " 0\n", + " 389.798315\n", + " 386.933197\n", + " 383.791193\n", + " 347.890677\n", + " 105912170.0\n", + " 391.287419\n", + " 388.092832\n", + " 382.369221\n", " \n", " \n", - " 2020-10-02\n", - " 330.447\n", - " 333.5965\n", - " 335.6440\n", - " 310.62810\n", - " 86036292.75\n", - " 333.124901\n", - " 334.199576\n", - " 332.142007\n", + " 2021-03-19\n", + " 1.278\n", + " 0\n", + " 390.508554\n", + " 386.969362\n", + " 384.134183\n", + " 348.301813\n", + " 107389010.0\n", + " 390.885773\n", + " 388.218939\n", + " 382.648076\n", " \n", " \n", "\n", "" ], "text/plain": [ - " SMA_10 SMA_20 SMA_50 SMA_200 VOL_SMA_20 EMA_8 \\\n", - "date \n", - "2020-09-28 331.181 336.9395 334.8642 310.30500 86281647.00 330.408828 \n", - "2020-09-29 330.401 336.0925 335.0252 310.38120 85553267.55 330.844644 \n", - "2020-09-30 330.008 335.2070 335.2228 310.46905 88007358.10 331.743612 \n", - "2020-10-01 330.128 334.1740 335.4264 310.55675 88965293.60 332.920587 \n", - "2020-10-02 330.447 333.5965 335.6440 310.62810 86036292.75 333.124901 \n", + " dividends split SMA_10 SMA_20 SMA_50 SMA_200 \\\n", + "date \n", + "2021-03-15 0.000 0 385.812372 386.472707 382.382806 346.504071 \n", + "2021-03-16 0.000 0 386.746310 386.652617 382.821967 346.979575 \n", + "2021-03-17 0.000 0 388.325140 386.895322 383.389508 347.455754 \n", + "2021-03-18 0.000 0 389.798315 386.933197 383.791193 347.890677 \n", + "2021-03-19 1.278 0 390.508554 386.969362 384.134183 348.301813 \n", "\n", - " EMA_21 EMA_50 \n", - "date \n", - "2020-09-28 334.010756 331.721246 \n", - "2020-09-29 333.861596 331.746687 \n", - "2020-09-30 333.955087 331.869955 \n", - "2020-10-01 334.235534 332.072702 \n", - "2020-10-02 334.199576 332.142007 " + " VOL_SMA_20 EMA_8 EMA_21 EMA_50 \n", + "date \n", + "2021-03-15 100066335.0 389.130999 386.319421 380.945454 \n", + "2021-03-16 101165615.0 390.350227 387.073794 381.481613 \n", + "2021-03-17 103142185.0 391.597540 387.881916 382.049516 \n", + "2021-03-18 105912170.0 391.287419 388.092832 382.369221 \n", + "2021-03-19 107389010.0 390.885773 388.218939 382.648076 " ] }, "execution_count": 7, @@ -371,38 +396,38 @@ " \n", " \n", " \n", - " 2020-09-28\n", - " 0.0\n", - " 0.0\n", - " 0\n", + " 2021-03-15\n", + " 0.023585\n", + " 0.005946\n", + " 1\n", " 0\n", " \n", " \n", - " 2020-09-29\n", - " 0.0\n", - " 0.0\n", - " 0\n", + " 2021-03-16\n", + " 0.022323\n", + " -0.001262\n", + " 1\n", " 0\n", " \n", " \n", - " 2020-09-30\n", - " 0.0\n", - " 0.0\n", - " 0\n", + " 2021-03-17\n", + " 0.025727\n", + " 0.003404\n", + " 1\n", " 0\n", " \n", " \n", - " 2020-10-01\n", - " 0.0\n", - " 0.0\n", - " 0\n", + " 2021-03-18\n", + " 0.011071\n", + " -0.014657\n", + " 1\n", " 0\n", " \n", " \n", - " 2020-10-02\n", - " 0.0\n", - " 0.0\n", - " 0\n", + " 2021-03-19\n", + " 0.009219\n", + " -0.001852\n", + " 1\n", " 0\n", " \n", " \n", @@ -410,13 +435,13 @@ "" ], "text/plain": [ - " CLTR TR_LOGRET CLTR_Trends CLTR_Trades\n", - "date \n", - "2020-09-28 0.0 0.0 0 0\n", - "2020-09-29 0.0 0.0 0 0\n", - "2020-09-30 0.0 0.0 0 0\n", - "2020-10-01 0.0 0.0 0 0\n", - "2020-10-02 0.0 0.0 0 0" + " CLTR TR_LOGRET CLTR_Trends CLTR_Trades\n", + "date \n", + "2021-03-15 0.023585 0.005946 1 0\n", + "2021-03-16 0.022323 -0.001262 1 0\n", + "2021-03-17 0.025727 0.003404 1 0\n", + "2021-03-18 0.011071 -0.014657 1 0\n", + "2021-03-19 0.009219 -0.001852 1 0" ] }, "execution_count": 8, @@ -444,7 +469,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 9, @@ -453,7 +478,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -474,150 +499,19 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Trend Returns and Cumulative Trend Returns" + "## Entries & Exits" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "cltr = trendy.iloc[:,0]\n", - "tr = trendy.iloc[:,1]\n", - "\n", - "trendy.iloc[:,:2].plot(figsize=(16, 3), color=colors(\"BkBl\"))\n", - "cltr.plot(figsize=(16, 3), kind=\"area\", stacked=False, color=colors(\"SvGy\")[0], alpha=0.25, grid=True)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Total Return" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "capital = 10000\n", - "\n", - "total_return = cltr.cumsum() * capital\n", - "positive_return = total_return[total_return > 0]\n", - "negative_return = total_return[total_return <= 0]\n", - "trdf = pd.DataFrame({\"tr+\": positive_return, \"tr-\": negative_return})\n", - "trdf.plot(figsize=(16, 5), color=colors(), kind=\"area\", stacked=False, alpha=0.25, grid=True)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Long and Short Trends" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "long_trend = (trendy.iloc[:,-2] > 0).astype(int)\n", - "short_trend = (1 - long_trend).astype(int)\n", - "\n", - "long_trend.plot(figsize=(16, 0.85), kind=\"area\", stacked=True, color=colors()[0], alpha=0.25)\n", - "short_trend.plot(figsize=(16, 0.85), kind=\"area\", stacked=True, color=colors()[1], alpha=0.25)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Entries & Exits" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Total Trades: 6\n" + "Total Trades: 7\n" ] }, { @@ -654,57 +548,64 @@ " \n", " \n", " \n", - " 2019-10-31\n", + " 2020-04-17\n", " 1\n", - " 303.33\n", - " NaN\n", - " \n", - " \n", - " 2020-02-24\n", - " -1\n", - " NaN\n", - " 322.42\n", - " \n", - " \n", - " 2020-04-08\n", - " 1\n", - " 274.03\n", - " NaN\n", - " \n", - " \n", - " 2020-06-26\n", - " -1\n", - " NaN\n", - " 300.05\n", - " \n", - " \n", - " 2020-06-29\n", - " 1\n", - " 304.46\n", + " 282.115784\n", " NaN\n", " \n", " \n", " 2020-09-10\n", " -1\n", " NaN\n", - " 333.89\n", + " 330.066162\n", + " \n", + " \n", + " 2020-10-02\n", + " 1\n", + " 331.337799\n", + " NaN\n", + " \n", + " \n", + " 2020-10-27\n", + " -1\n", + " NaN\n", + " 335.684937\n", + " \n", + " \n", + " 2020-11-04\n", + " 1\n", + " 340.965088\n", + " NaN\n", + " \n", + " \n", + " 2021-03-02\n", + " -1\n", + " NaN\n", + " 385.278137\n", + " \n", + " \n", + " 2021-03-09\n", + " 1\n", + " 385.906067\n", + " NaN\n", " \n", " \n", "\n", "" ], "text/plain": [ - " Signal Entry Exit\n", - "date \n", - "2019-10-31 1 303.33 NaN\n", - "2020-02-24 -1 NaN 322.42\n", - "2020-04-08 1 274.03 NaN\n", - "2020-06-26 -1 NaN 300.05\n", - "2020-06-29 1 304.46 NaN\n", - "2020-09-10 -1 NaN 333.89" + " Signal Entry Exit\n", + "date \n", + "2020-04-17 1 282.115784 NaN\n", + "2020-09-10 -1 NaN 330.066162\n", + "2020-10-02 1 331.337799 NaN\n", + "2020-10-27 -1 NaN 335.684937\n", + "2020-11-04 1 340.965088 NaN\n", + "2021-03-02 -1 NaN 385.278137\n", + "2021-03-09 1 385.906067 NaN" ] }, - "execution_count": 13, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -738,14 +639,14 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "first_date, last_date = asset.index[0], asset.index[-1]\n", "f_date = f\"{first_date.day_name()} {first_date.month}-{first_date.day}-{first_date.year}\"\n", "l_date = f\"{last_date.day_name()} {last_date.month}-{last_date.day}-{last_date.year}\"\n", - "last_ohlcv = f\"Last OHLCV: ({asset.iloc[-1].open}, {asset.iloc[-1].high}, {asset.iloc[-1].low}, {asset.iloc[-1].close}, {int(asset.iloc[-1].volume)})\"\n", + "last_ohlcv = f\"Last OHLCV: ({asset.iloc[-1].open:.4f}, {asset.iloc[-1].high:.4f}, {asset.iloc[-1].low:.4f}, {asset.iloc[-1].close:.4f}, {int(asset.iloc[-1].volume)})\"\n", "ptitle = f\"\\n{ticker} [{tf} for {duration}({recent} bars)] from {f_date} to {l_date}\\n{last_ohlcv}\\n{extime}\"" ] }, @@ -758,22 +659,22 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 15, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -793,6 +694,137 @@ "exits.plot(figsize=(16, 10), color=colors(\"FcLi\")[0], marker=\"v\", markersize=12, alpha=0.8, grid=True)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Trend Returns and Cumulative Trend Returns" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "cltr = trendy.iloc[:,0]\n", + "tr = trendy.iloc[:,1]\n", + "\n", + "trendy.iloc[:,:2].plot(figsize=(16, 3), color=colors(\"BkBl\"))\n", + "cltr.plot(figsize=(16, 3), kind=\"area\", stacked=False, color=colors(\"SvGy\")[0], alpha=0.25, grid=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Total Return" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "capital = 10000\n", + "\n", + "total_return = cltr.cumsum() * capital\n", + "positive_return = total_return[total_return > 0]\n", + "negative_return = total_return[total_return <= 0]\n", + "trdf = pd.DataFrame({\"tr+\": positive_return, \"tr-\": negative_return})\n", + "trdf.plot(figsize=(16, 5), color=colors(), kind=\"area\", stacked=False, alpha=0.25, grid=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Long and Short Trends" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "long_trend = (trendy.iloc[:,-2] > 0).astype(int)\n", + "short_trend = (1 - long_trend).astype(int)\n", + "\n", + "long_trend.plot(figsize=(16, 0.85), kind=\"area\", stacked=True, color=colors()[0], alpha=0.25)\n", + "short_trend.plot(figsize=(16, 0.85), kind=\"area\", stacked=True, color=colors()[1], alpha=0.25)" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -806,6 +838,23 @@ "metadata": {}, "outputs": [], "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Disclaimer\n", + "* All investments involve risk, and the past performance of a security, industry, sector, market, financial product, trading strategy, or individual’s trading does not guarantee future results or returns. Investors are fully responsible for any investment decisions they make. Such decisions should be based solely on an evaluation of their financial circumstances, investment objectives, risk tolerance, and liquidity needs.\n", + "\n", + "* Any opinions, news, research, analyses, prices, or other information offered is provided as general market commentary, and does not constitute investment advice. I will not accept liability for any loss or damage, including without limitation any loss of profit, which may arise directly or indirectly from use of or reliance on such information." + ] } ], "metadata": { @@ -824,7 +873,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.2" + "version": "3.9.1" } }, "nbformat": 4, diff --git a/examples/PandasTA_Strategy_Examples.ipynb b/examples/PandasTA_Strategy_Examples.ipynb index a4ebfe6..dabed57 100644 --- a/examples/PandasTA_Strategy_Examples.ipynb +++ b/examples/PandasTA_Strategy_Examples.ipynb @@ -26,6 +26,11 @@ "name": "stdout", "output_type": "stream", "text": [ + "\n", + "Pandas TA v0.2.49b0\n", + "To install the Latest Version:\n", + "$ pip install -U git+https://github.com/twopirllc/pandas-ta\n", + "\n", "Populating the interactive namespace from numpy and matplotlib\n" ] } @@ -39,6 +44,8 @@ "from alphaVantageAPI.alphavantage import AlphaVantage # pip install alphaVantage-api\n", "\n", "from watchlist import Watchlist # Is this failing? If so, copy it locally. See above.\n", + "\n", + "print(f\"\\nPandas TA v{ta.version}\\nTo install the Latest Version:\\n$ pip install -U git+https://github.com/twopirllc/pandas-ta\\n\")\n", "%pylab inline" ] }, @@ -86,7 +93,7 @@ "text": [ "name = All\n", "description = All the indicators with their default settings. Pandas TA default.\n", - "created = 01/23/2021, 12:36:24\n", + "created = Saturday March 20, 2021, NYSE: 13:13:10, Local: 17:13:10 PDT, Day 79/365 (22.0%)\n", "ta = None\n" ] } @@ -117,7 +124,7 @@ "text": [ "name = Common Price and Volume SMAs\n", "description = Common Price SMAs: 10, 20, 50, 200 and Volume SMA: 20.\n", - "created = 01/23/2021, 12:36:24\n", + "created = Saturday March 20, 2021, NYSE: 13:13:10, Local: 17:13:10 PDT, Day 79/365 (22.0%)\n", "ta = [{'kind': 'sma', 'length': 10}, {'kind': 'sma', 'length': 20}, {'kind': 'sma', 'length': 50}, {'kind': 'sma', 'length': 200}, {'kind': 'sma', 'close': 'volume', 'length': 20, 'prefix': 'VOL'}]\n" ] } @@ -159,7 +166,7 @@ { "data": { "text/plain": [ - "Strategy(name='A', ta=[{'kind': 'sma', 'length': 50}, {'kind': 'sma', 'length': 200}], description='TA Description', created='01/23/2021, 12:36:24')" + "Strategy(name='A', ta=[{'kind': 'sma', 'length': 50}, {'kind': 'sma', 'length': 200}], description='TA Description', created='Saturday March 20, 2021, NYSE: 13:13:10, Local: 17:13:10 PDT, Day 79/365 (22.0%)')" ] }, "execution_count": 4, @@ -187,7 +194,7 @@ { "data": { "text/plain": [ - "Strategy(name='B', ta=[{'kind': 'ema', 'length': 8}, {'kind': 'ema', 'length': 21}, {'kind': 'log_return', 'cumulative': True}, {'kind': 'rsi'}, {'kind': 'supertrend'}], description='TA Description', created='01/23/2021, 12:36:24')" + "Strategy(name='B', ta=[{'kind': 'ema', 'length': 8}, {'kind': 'ema', 'length': 21}, {'kind': 'log_return', 'cumulative': True}, {'kind': 'rsi'}, {'kind': 'supertrend'}], description='TA Description', created='Saturday March 20, 2021, NYSE: 13:13:10, Local: 17:13:10 PDT, Day 79/365 (22.0%)')" ] }, "execution_count": 5, @@ -215,7 +222,7 @@ { "data": { "text/plain": [ - "Strategy(name='Runtime Failure', ta=[{'kind': 'percet_return'}], description='TA Description', created='01/23/2021, 12:36:24')" + "Strategy(name='Runtime Failure', ta=[{'kind': 'percet_return'}], description='TA Description', created='Saturday March 20, 2021, NYSE: 13:13:10, Local: 17:13:10 PDT, Day 79/365 (22.0%)')" ] }, "execution_count": 6, @@ -298,7 +305,9 @@ "metadata": {}, "outputs": [], "source": [ - "watch = Watchlist([\"SPY\", \"IWM\"], timed=False)" + "data_source = \"av\" # Default\n", + "# data_source = \"yahoo\"\n", + "watch = Watchlist([\"SPY\", \"IWM\"], ds_name=data_source, timed=False)" ] }, { @@ -316,7 +325,7 @@ { "data": { "text/plain": [ - "Watch(name='Watch: SPY, IWM', tickers[2]='SPY, IWM', tf='D', strategy[5]='Common Price and Volume SMAs')" + "Watch(name='Watch: SPY, IWM', ds_name='av', tickers[2]='SPY, IWM', tf='D', strategy[5]='Common Price and Volume SMAs')" ] }, "execution_count": 9, @@ -347,7 +356,7 @@ "Help on class Watchlist in module watchlist:\n", "\n", "class Watchlist(builtins.object)\n", - " | Watchlist(tickers: list, tf: str = None, name: str = None, strategy: pandas_ta.core.Strategy = None, ds: object = None, **kwargs)\n", + " | Watchlist(tickers: list, tf: str = None, name: str = None, strategy: pandas_ta.core.Strategy = None, ds_name: str = 'av', **kwargs)\n", " | \n", " | # Watchlist Class (** This is subject to change! **)\n", " | A simple Class to load/download financial market data and automatically\n", @@ -369,7 +378,7 @@ " | \n", " | Methods defined here:\n", " | \n", - " | __init__(self, tickers: list, tf: str = None, name: str = None, strategy: pandas_ta.core.Strategy = None, ds: object = None, **kwargs)\n", + " | __init__(self, tickers: list, tf: str = None, name: str = None, strategy: pandas_ta.core.Strategy = None, ds_name: str = 'av', **kwargs)\n", " | Initialize self. See help(type(self)) for accurate signature.\n", " | \n", " | __repr__(self) -> str\n", @@ -438,18 +447,20 @@ "output_type": "stream", "text": [ "[!] Loading All: SPY, IWM\n", - "[i] Loaded['D']: SPY_D.csv\n", + "[+] Downloading[av]: SPY[D]\n", "[+] Strategy: Common Price and Volume SMAs\n", "[i] Indicator arguments: {'timed': False, 'append': True}\n", - "[i] Multiprocessing: 8 of 8 cores.\n", + "[i] Multiprocessing 5 indicators with 7 chunks over 8/8 cpus.\n", "[i] Total indicators: 5\n", "[i] Columns added: 5\n", - "[i] Loaded['D']: IWM_D.csv\n", + "[i] Last Run: Saturday March 20, 2021, NYSE: 13:13:13, Local: 17:13:13 PDT, Day 79/365 (22.0%)\n", + "[+] Downloading[av]: IWM[D]\n", "[+] Strategy: Common Price and Volume SMAs\n", "[i] Indicator arguments: {'timed': False, 'append': True}\n", - "[i] Multiprocessing: 8 of 8 cores.\n", + "[i] Multiprocessing 5 indicators with 7 chunks over 8/8 cpus.\n", "[i] Total indicators: 5\n", - "[i] Columns added: 5\n" + "[i] Columns added: 5\n", + "[i] Last Run: Saturday March 20, 2021, NYSE: 13:13:30, Local: 17:13:30 PDT, Day 79/365 (22.0%)\n" ] } ], @@ -476,40 +487,40 @@ " 1999-11-04 136.7500 137.3593 135.7656 136.5312 7907500.0 NaN \n", " 1999-11-05 138.6250 139.1093 136.7812 137.8750 7431500.0 NaN \n", " ... ... ... ... ... ... ... \n", - " 2020-09-28 333.2200 334.9600 332.1500 334.1900 64584614.0 331.181 \n", - " 2020-09-29 333.9700 334.7700 331.6209 332.3700 51531594.0 330.401 \n", - " 2020-09-30 333.0900 338.2900 332.8800 334.8900 104081136.0 330.008 \n", - " 2020-10-01 337.6900 338.7400 335.0100 337.0400 88698745.0 330.128 \n", - " 2020-10-02 331.7000 337.0126 331.1900 333.8400 89431112.0 330.447 \n", + " 2021-03-15 394.3300 396.6850 392.0300 396.4100 73592302.0 387.076 \n", + " 2021-03-16 397.0700 397.8300 395.0800 395.9100 73722506.0 388.013 \n", + " 2021-03-17 394.5300 398.1200 393.3000 397.2600 97959265.0 389.597 \n", + " 2021-03-18 394.4750 396.7200 390.7500 391.4800 115349101.0 391.075 \n", + " 2021-03-19 389.8800 391.5690 387.1500 389.4800 113624490.0 391.660 \n", " \n", - " SMA_20 SMA_50 SMA_200 VOL_SMA_20 \n", - " date \n", - " 1999-11-01 NaN NaN NaN NaN \n", - " 1999-11-02 NaN NaN NaN NaN \n", - " 1999-11-03 NaN NaN NaN NaN \n", - " 1999-11-04 NaN NaN NaN NaN \n", - " 1999-11-05 NaN NaN NaN NaN \n", - " ... ... ... ... ... \n", - " 2020-09-28 336.9395 334.8642 310.30500 86281647.00 \n", - " 2020-09-29 336.0925 335.0252 310.38120 85553267.55 \n", - " 2020-09-30 335.2070 335.2228 310.46905 88007358.10 \n", - " 2020-10-01 334.1740 335.4264 310.55675 88965293.60 \n", - " 2020-10-02 333.5965 335.6440 310.62810 86036292.75 \n", + " SMA_20 SMA_50 SMA_200 VOL_SMA_20 \n", + " date \n", + " 1999-11-01 NaN NaN NaN NaN \n", + " 1999-11-02 NaN NaN NaN NaN \n", + " 1999-11-03 NaN NaN NaN NaN \n", + " 1999-11-04 NaN NaN NaN NaN \n", + " 1999-11-05 NaN NaN NaN NaN \n", + " ... ... ... ... ... \n", + " 2021-03-15 387.7385 383.6352 349.25675 9.988408e+07 \n", + " 2021-03-16 387.9190 384.0758 349.71470 1.010216e+08 \n", + " 2021-03-17 388.1625 384.6452 350.17325 1.033322e+08 \n", + " 2021-03-18 388.2005 385.0482 350.59025 1.061140e+08 \n", + " 2021-03-19 388.1730 385.3668 350.97675 1.076332e+08 \n", " \n", - " [5265 rows x 10 columns],\n", - " 'IWM': open high low close volume SMA_10 SMA_20 \\\n", - " date \n", - " 2000-05-26 91.06 91.44 90.630 91.44 37400.0 NaN NaN \n", - " 2000-05-30 92.75 94.81 92.750 94.81 28800.0 NaN NaN \n", - " 2000-05-31 95.13 96.38 95.130 95.75 18000.0 NaN NaN \n", - " 2000-06-01 97.11 97.31 97.110 97.31 3500.0 NaN NaN \n", - " 2000-06-02 101.70 102.40 101.700 102.40 14700.0 NaN NaN \n", - " ... ... ... ... ... ... ... ... \n", - " 2020-09-28 148.37 150.44 146.404 150.02 17600904.0 149.672 151.4385 \n", - " 2020-09-29 149.85 150.28 148.000 149.34 18703037.0 149.269 151.1340 \n", - " 2020-09-30 149.90 151.97 148.490 149.79 29073746.0 148.766 150.7630 \n", - " 2020-10-01 150.81 152.20 149.490 152.18 25871962.0 148.615 150.4490 \n", - " 2020-10-02 149.41 153.58 148.990 152.85 29451992.0 148.571 150.4025 \n", + " [5380 rows x 10 columns],\n", + " 'IWM': open high low close volume SMA_10 SMA_20 \\\n", + " date \n", + " 2000-05-26 91.06 91.44 90.63 91.44 37400.0 NaN NaN \n", + " 2000-05-30 92.75 94.81 92.75 94.81 28800.0 NaN NaN \n", + " 2000-05-31 95.13 96.38 95.13 95.75 18000.0 NaN NaN \n", + " 2000-06-01 97.11 97.31 97.11 97.31 3500.0 NaN NaN \n", + " 2000-06-02 101.70 102.40 101.70 102.40 14700.0 NaN NaN \n", + " ... ... ... ... ... ... ... ... \n", + " 2021-03-15 233.34 234.53 231.91 234.42 21543170.0 224.147 223.6310 \n", + " 2021-03-16 234.02 234.09 229.12 230.50 24675008.0 225.025 223.8645 \n", + " 2021-03-17 228.97 232.82 227.36 232.31 29422584.0 226.324 224.2770 \n", + " 2021-03-18 230.80 232.93 224.61 225.24 35726301.0 227.529 224.5095 \n", + " 2021-03-19 224.57 228.60 222.95 226.94 40855626.0 228.452 224.5970 \n", " \n", " SMA_50 SMA_200 VOL_SMA_20 \n", " date \n", @@ -519,13 +530,13 @@ " 2000-06-01 NaN NaN NaN \n", " 2000-06-02 NaN NaN NaN \n", " ... ... ... ... \n", - " 2020-09-28 152.3430 144.94380 24197653.10 \n", - " 2020-09-29 152.4106 144.87070 24280229.40 \n", - " 2020-09-30 152.4458 144.80300 24951209.50 \n", - " 2020-10-01 152.5272 144.74450 25406635.15 \n", - " 2020-10-02 152.6190 144.68525 25273355.50 \n", + " 2021-03-15 217.0930 173.82090 33326068.35 \n", + " 2021-03-16 217.7818 174.27890 33409843.35 \n", + " 2021-03-17 218.5580 174.73930 33633447.20 \n", + " 2021-03-18 219.1330 175.15855 34194686.80 \n", + " 2021-03-19 219.5812 175.56925 34675560.35 \n", " \n", - " [5121 rows x 10 columns]}" + " [5236 rows x 10 columns]}" ] }, "execution_count": 12, @@ -537,13 +548,6 @@ "watch.data" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### " - ] - }, { "cell_type": "code", "execution_count": 13, @@ -675,73 +679,73 @@ " ...\n", " \n", " \n", - " 2020-09-28\n", - " 333.2200\n", - " 334.9600\n", - " 332.1500\n", - " 334.1900\n", - " 64584614.0\n", - " 331.181\n", - " 336.9395\n", - " 334.8642\n", - " 310.30500\n", - " 86281647.00\n", + " 2021-03-15\n", + " 394.3300\n", + " 396.6850\n", + " 392.0300\n", + " 396.4100\n", + " 73592302.0\n", + " 387.076\n", + " 387.7385\n", + " 383.6352\n", + " 349.25675\n", + " 9.988408e+07\n", " \n", " \n", - " 2020-09-29\n", - " 333.9700\n", - " 334.7700\n", - " 331.6209\n", - " 332.3700\n", - " 51531594.0\n", - " 330.401\n", - " 336.0925\n", - " 335.0252\n", - " 310.38120\n", - " 85553267.55\n", + " 2021-03-16\n", + " 397.0700\n", + " 397.8300\n", + " 395.0800\n", + " 395.9100\n", + " 73722506.0\n", + " 388.013\n", + " 387.9190\n", + " 384.0758\n", + " 349.71470\n", + " 1.010216e+08\n", " \n", " \n", - " 2020-09-30\n", - " 333.0900\n", - " 338.2900\n", - " 332.8800\n", - " 334.8900\n", - " 104081136.0\n", - " 330.008\n", - " 335.2070\n", - " 335.2228\n", - " 310.46905\n", - " 88007358.10\n", + " 2021-03-17\n", + " 394.5300\n", + " 398.1200\n", + " 393.3000\n", + " 397.2600\n", + " 97959265.0\n", + " 389.597\n", + " 388.1625\n", + " 384.6452\n", + " 350.17325\n", + " 1.033322e+08\n", " \n", " \n", - " 2020-10-01\n", - " 337.6900\n", - " 338.7400\n", - " 335.0100\n", - " 337.0400\n", - " 88698745.0\n", - " 330.128\n", - " 334.1740\n", - " 335.4264\n", - " 310.55675\n", - " 88965293.60\n", + " 2021-03-18\n", + " 394.4750\n", + " 396.7200\n", + " 390.7500\n", + " 391.4800\n", + " 115349101.0\n", + " 391.075\n", + " 388.2005\n", + " 385.0482\n", + " 350.59025\n", + " 1.061140e+08\n", " \n", " \n", - " 2020-10-02\n", - " 331.7000\n", - " 337.0126\n", - " 331.1900\n", - " 333.8400\n", - " 89431112.0\n", - " 330.447\n", - " 333.5965\n", - " 335.6440\n", - " 310.62810\n", - " 86036292.75\n", + " 2021-03-19\n", + " 389.8800\n", + " 391.5690\n", + " 387.1500\n", + " 389.4800\n", + " 113624490.0\n", + " 391.660\n", + " 388.1730\n", + " 385.3668\n", + " 350.97675\n", + " 1.076332e+08\n", " \n", " \n", "\n", - "

5265 rows × 10 columns

\n", + "

5380 rows × 10 columns

\n", "" ], "text/plain": [ @@ -753,27 +757,27 @@ "1999-11-04 136.7500 137.3593 135.7656 136.5312 7907500.0 NaN \n", "1999-11-05 138.6250 139.1093 136.7812 137.8750 7431500.0 NaN \n", "... ... ... ... ... ... ... \n", - "2020-09-28 333.2200 334.9600 332.1500 334.1900 64584614.0 331.181 \n", - "2020-09-29 333.9700 334.7700 331.6209 332.3700 51531594.0 330.401 \n", - "2020-09-30 333.0900 338.2900 332.8800 334.8900 104081136.0 330.008 \n", - "2020-10-01 337.6900 338.7400 335.0100 337.0400 88698745.0 330.128 \n", - "2020-10-02 331.7000 337.0126 331.1900 333.8400 89431112.0 330.447 \n", + "2021-03-15 394.3300 396.6850 392.0300 396.4100 73592302.0 387.076 \n", + "2021-03-16 397.0700 397.8300 395.0800 395.9100 73722506.0 388.013 \n", + "2021-03-17 394.5300 398.1200 393.3000 397.2600 97959265.0 389.597 \n", + "2021-03-18 394.4750 396.7200 390.7500 391.4800 115349101.0 391.075 \n", + "2021-03-19 389.8800 391.5690 387.1500 389.4800 113624490.0 391.660 \n", "\n", - " SMA_20 SMA_50 SMA_200 VOL_SMA_20 \n", - "date \n", - "1999-11-01 NaN NaN NaN NaN \n", - "1999-11-02 NaN NaN NaN NaN \n", - "1999-11-03 NaN NaN NaN NaN \n", - "1999-11-04 NaN NaN NaN NaN \n", - "1999-11-05 NaN NaN NaN NaN \n", - "... ... ... ... ... \n", - "2020-09-28 336.9395 334.8642 310.30500 86281647.00 \n", - "2020-09-29 336.0925 335.0252 310.38120 85553267.55 \n", - "2020-09-30 335.2070 335.2228 310.46905 88007358.10 \n", - "2020-10-01 334.1740 335.4264 310.55675 88965293.60 \n", - "2020-10-02 333.5965 335.6440 310.62810 86036292.75 \n", + " SMA_20 SMA_50 SMA_200 VOL_SMA_20 \n", + "date \n", + "1999-11-01 NaN NaN NaN NaN \n", + "1999-11-02 NaN NaN NaN NaN \n", + "1999-11-03 NaN NaN NaN NaN \n", + "1999-11-04 NaN NaN NaN NaN \n", + "1999-11-05 NaN NaN NaN NaN \n", + "... ... ... ... ... \n", + "2021-03-15 387.7385 383.6352 349.25675 9.988408e+07 \n", + "2021-03-16 387.9190 384.0758 349.71470 1.010216e+08 \n", + "2021-03-17 388.1625 384.6452 350.17325 1.033322e+08 \n", + "2021-03-18 388.2005 385.0482 350.59025 1.061140e+08 \n", + "2021-03-19 388.1730 385.3668 350.97675 1.076332e+08 \n", "\n", - "[5265 rows x 10 columns]" + "[5380 rows x 10 columns]" ] }, "execution_count": 13, @@ -792,6 +796,273 @@ "outputs": [], "source": [] }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[i] Loaded SPY[D]: SPY_D.csv\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
openhighlowclosevolumeSMA_10SMA_20SMA_50SMA_200VOL_SMA_20
date
1999-11-01136.5000137.0000135.5625135.56254006500.0NaNNaNNaNNaNNaN
1999-11-02135.9687137.2500134.5937134.59376516900.0NaNNaNNaNNaNNaN
1999-11-03136.0000136.3750135.1250135.50007222300.0NaNNaNNaNNaNNaN
1999-11-04136.7500137.3593135.7656136.53127907500.0NaNNaNNaNNaNNaN
1999-11-05138.6250139.1093136.7812137.87507431500.0NaNNaNNaNNaNNaN
.................................
2021-03-15394.3300396.6850392.0300396.410073592302.0387.076387.7385383.6352349.256759.988408e+07
2021-03-16397.0700397.8300395.0800395.910073722506.0388.013387.9190384.0758349.714701.010216e+08
2021-03-17394.5300398.1200393.3000397.260097959265.0389.597388.1625384.6452350.173251.033322e+08
2021-03-18394.4750396.7200390.7500391.4800115349101.0391.075388.2005385.0482350.590251.061140e+08
2021-03-19389.8800391.5690387.1500389.4800113624490.0391.660388.1730385.3668350.976751.076332e+08
\n", + "

5380 rows × 10 columns

\n", + "
" + ], + "text/plain": [ + " open high low close volume SMA_10 \\\n", + "date \n", + "1999-11-01 136.5000 137.0000 135.5625 135.5625 4006500.0 NaN \n", + "1999-11-02 135.9687 137.2500 134.5937 134.5937 6516900.0 NaN \n", + "1999-11-03 136.0000 136.3750 135.1250 135.5000 7222300.0 NaN \n", + "1999-11-04 136.7500 137.3593 135.7656 136.5312 7907500.0 NaN \n", + "1999-11-05 138.6250 139.1093 136.7812 137.8750 7431500.0 NaN \n", + "... ... ... ... ... ... ... \n", + "2021-03-15 394.3300 396.6850 392.0300 396.4100 73592302.0 387.076 \n", + "2021-03-16 397.0700 397.8300 395.0800 395.9100 73722506.0 388.013 \n", + "2021-03-17 394.5300 398.1200 393.3000 397.2600 97959265.0 389.597 \n", + "2021-03-18 394.4750 396.7200 390.7500 391.4800 115349101.0 391.075 \n", + "2021-03-19 389.8800 391.5690 387.1500 389.4800 113624490.0 391.660 \n", + "\n", + " SMA_20 SMA_50 SMA_200 VOL_SMA_20 \n", + "date \n", + "1999-11-01 NaN NaN NaN NaN \n", + "1999-11-02 NaN NaN NaN NaN \n", + "1999-11-03 NaN NaN NaN NaN \n", + "1999-11-04 NaN NaN NaN NaN \n", + "1999-11-05 NaN NaN NaN NaN \n", + "... ... ... ... ... \n", + "2021-03-15 387.7385 383.6352 349.25675 9.988408e+07 \n", + "2021-03-16 387.9190 384.0758 349.71470 1.010216e+08 \n", + "2021-03-17 388.1625 384.6452 350.17325 1.033322e+08 \n", + "2021-03-18 388.2005 385.0482 350.59025 1.061140e+08 \n", + "2021-03-19 388.1730 385.3668 350.97675 1.076332e+08 \n", + "\n", + "[5380 rows x 10 columns]" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "watch.load(\"SPY\", plot=True, mas=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "markdown", "metadata": {}, @@ -808,16 +1079,16 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "Strategy(name='A', ta=[{'kind': 'sma', 'length': 50}, {'kind': 'sma', 'length': 200}], description='TA Description', created='01/23/2021, 12:36:24')" + "Strategy(name='A', ta=[{'kind': 'sma', 'length': 50}, {'kind': 'sma', 'length': 200}], description='TA Description', created='Saturday March 20, 2021, NYSE: 13:13:10, Local: 17:13:10 PDT, Day 79/365 (22.0%)')" ] }, - "execution_count": 14, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -831,14 +1102,14 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[i] Loaded['D']: IWM_D.csv\n" + "[i] Loaded IWM[D]: IWM_D.csv\n" ] }, { @@ -886,7 +1157,7 @@ " 2000-05-26\n", " 91.06\n", " 91.44\n", - " 90.630\n", + " 90.63\n", " 91.44\n", " 37400.0\n", " NaN\n", @@ -896,7 +1167,7 @@ " 2000-05-30\n", " 92.75\n", " 94.81\n", - " 92.750\n", + " 92.75\n", " 94.81\n", " 28800.0\n", " NaN\n", @@ -906,7 +1177,7 @@ " 2000-05-31\n", " 95.13\n", " 96.38\n", - " 95.130\n", + " 95.13\n", " 95.75\n", " 18000.0\n", " NaN\n", @@ -916,7 +1187,7 @@ " 2000-06-01\n", " 97.11\n", " 97.31\n", - " 97.110\n", + " 97.11\n", " 97.31\n", " 3500.0\n", " NaN\n", @@ -926,7 +1197,7 @@ " 2000-06-02\n", " 101.70\n", " 102.40\n", - " 101.700\n", + " 101.70\n", " 102.40\n", " 14700.0\n", " NaN\n", @@ -943,79 +1214,79 @@ " ...\n", " \n", " \n", - " 2020-09-28\n", - " 148.37\n", - " 150.44\n", - " 146.404\n", - " 150.02\n", - " 17600904.0\n", - " 152.3430\n", - " 144.94380\n", + " 2021-03-15\n", + " 233.34\n", + " 234.53\n", + " 231.91\n", + " 234.42\n", + " 21543170.0\n", + " 217.0930\n", + " 173.82090\n", " \n", " \n", - " 2020-09-29\n", - " 149.85\n", - " 150.28\n", - " 148.000\n", - " 149.34\n", - " 18703037.0\n", - " 152.4106\n", - " 144.87070\n", + " 2021-03-16\n", + " 234.02\n", + " 234.09\n", + " 229.12\n", + " 230.50\n", + " 24675008.0\n", + " 217.7818\n", + " 174.27890\n", " \n", " \n", - " 2020-09-30\n", - " 149.90\n", - " 151.97\n", - " 148.490\n", - " 149.79\n", - " 29073746.0\n", - " 152.4458\n", - " 144.80300\n", + " 2021-03-17\n", + " 228.97\n", + " 232.82\n", + " 227.36\n", + " 232.31\n", + " 29422584.0\n", + " 218.5580\n", + " 174.73930\n", " \n", " \n", - " 2020-10-01\n", - " 150.81\n", - " 152.20\n", - " 149.490\n", - " 152.18\n", - " 25871962.0\n", - " 152.5272\n", - " 144.74450\n", + " 2021-03-18\n", + " 230.80\n", + " 232.93\n", + " 224.61\n", + " 225.24\n", + " 35726301.0\n", + " 219.1330\n", + " 175.15855\n", " \n", " \n", - " 2020-10-02\n", - " 149.41\n", - " 153.58\n", - " 148.990\n", - " 152.85\n", - " 29451992.0\n", - " 152.6190\n", - " 144.68525\n", + " 2021-03-19\n", + " 224.57\n", + " 228.60\n", + " 222.95\n", + " 226.94\n", + " 40855626.0\n", + " 219.5812\n", + " 175.56925\n", " \n", " \n", "\n", - "

5121 rows × 7 columns

\n", + "

5236 rows × 7 columns

\n", "" ], "text/plain": [ - " open high low close volume SMA_50 SMA_200\n", - "date \n", - "2000-05-26 91.06 91.44 90.630 91.44 37400.0 NaN NaN\n", - "2000-05-30 92.75 94.81 92.750 94.81 28800.0 NaN NaN\n", - "2000-05-31 95.13 96.38 95.130 95.75 18000.0 NaN NaN\n", - "2000-06-01 97.11 97.31 97.110 97.31 3500.0 NaN NaN\n", - "2000-06-02 101.70 102.40 101.700 102.40 14700.0 NaN NaN\n", - "... ... ... ... ... ... ... ...\n", - "2020-09-28 148.37 150.44 146.404 150.02 17600904.0 152.3430 144.94380\n", - "2020-09-29 149.85 150.28 148.000 149.34 18703037.0 152.4106 144.87070\n", - "2020-09-30 149.90 151.97 148.490 149.79 29073746.0 152.4458 144.80300\n", - "2020-10-01 150.81 152.20 149.490 152.18 25871962.0 152.5272 144.74450\n", - "2020-10-02 149.41 153.58 148.990 152.85 29451992.0 152.6190 144.68525\n", + " open high low close volume SMA_50 SMA_200\n", + "date \n", + "2000-05-26 91.06 91.44 90.63 91.44 37400.0 NaN NaN\n", + "2000-05-30 92.75 94.81 92.75 94.81 28800.0 NaN NaN\n", + "2000-05-31 95.13 96.38 95.13 95.75 18000.0 NaN NaN\n", + "2000-06-01 97.11 97.31 97.11 97.31 3500.0 NaN NaN\n", + "2000-06-02 101.70 102.40 101.70 102.40 14700.0 NaN NaN\n", + "... ... ... ... ... ... ... ...\n", + "2021-03-15 233.34 234.53 231.91 234.42 21543170.0 217.0930 173.82090\n", + "2021-03-16 234.02 234.09 229.12 230.50 24675008.0 217.7818 174.27890\n", + "2021-03-17 228.97 232.82 227.36 232.31 29422584.0 218.5580 174.73930\n", + "2021-03-18 230.80 232.93 224.61 225.24 35726301.0 219.1330 175.15855\n", + "2021-03-19 224.57 228.60 222.95 226.94 40855626.0 219.5812 175.56925\n", "\n", - "[5121 rows x 7 columns]" + "[5236 rows x 7 columns]" ] }, - "execution_count": 15, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } @@ -1033,16 +1304,16 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "Strategy(name='B', ta=[{'kind': 'ema', 'length': 8}, {'kind': 'ema', 'length': 21}, {'kind': 'log_return', 'cumulative': True}, {'kind': 'rsi'}, {'kind': 'supertrend'}], description='TA Description', created='01/23/2021, 12:36:24')" + "Strategy(name='B', ta=[{'kind': 'ema', 'length': 8}, {'kind': 'ema', 'length': 21}, {'kind': 'log_return', 'cumulative': True}, {'kind': 'rsi'}, {'kind': 'supertrend'}], description='TA Description', created='Saturday March 20, 2021, NYSE: 13:13:10, Local: 17:13:10 PDT, Day 79/365 (22.0%)')" ] }, - "execution_count": 16, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } @@ -1055,14 +1326,14 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[i] Loaded['D']: SPY_D.csv\n" + "[i] Loaded SPY[D]: SPY_D.csv\n" ] }, { @@ -1215,88 +1486,88 @@ " ...\n", " \n", " \n", - " 2020-09-28\n", - " 333.2200\n", - " 334.9600\n", - " 332.1500\n", - " 334.1900\n", - " 64584614.0\n", - " 330.408828\n", - " 334.010756\n", - " 0.902277\n", - " 49.833349\n", - " 344.119874\n", + " 2021-03-15\n", + " 394.3300\n", + " 396.6850\n", + " 392.0300\n", + " 396.4100\n", + " 73592302.0\n", + " 390.405499\n", + " 387.590872\n", + " 1.073016\n", + " 61.444065\n", + " 398.910421\n", " -1\n", " NaN\n", - " 344.119874\n", + " 398.910421\n", " \n", " \n", - " 2020-09-29\n", - " 333.9700\n", - " 334.7700\n", - " 331.6209\n", - " 332.3700\n", - " 51531594.0\n", - " 330.844644\n", - " 333.861596\n", - " 0.896816\n", - " 48.051629\n", - " 344.119874\n", + " 2021-03-16\n", + " 397.0700\n", + " 397.8300\n", + " 395.0800\n", + " 395.9100\n", + " 73722506.0\n", + " 391.628722\n", + " 388.347156\n", + " 1.071754\n", + " 60.730184\n", + " 398.910421\n", " -1\n", " NaN\n", - " 344.119874\n", + " 398.910421\n", " \n", " \n", - " 2020-09-30\n", - " 333.0900\n", - " 338.2900\n", - " 332.8800\n", - " 334.8900\n", - " 104081136.0\n", - " 331.743612\n", - " 333.955087\n", - " 0.904369\n", - " 50.680975\n", - " 344.119874\n", + " 2021-03-17\n", + " 394.5300\n", + " 398.1200\n", + " 393.3000\n", + " 397.2600\n", + " 97959265.0\n", + " 392.880117\n", + " 389.157415\n", + " 1.075158\n", + " 62.013471\n", + " 398.910421\n", " -1\n", " NaN\n", - " 344.119874\n", + " 398.910421\n", " \n", " \n", - " 2020-10-01\n", - " 337.6900\n", - " 338.7400\n", - " 335.0100\n", - " 337.0400\n", - " 88698745.0\n", - " 332.920587\n", - " 334.235534\n", - " 0.910769\n", - " 52.872627\n", - " 344.119874\n", + " 2021-03-18\n", + " 394.4750\n", + " 396.7200\n", + " 390.7500\n", + " 391.4800\n", + " 115349101.0\n", + " 392.568980\n", + " 389.368559\n", + " 1.060502\n", + " 53.893084\n", + " 398.910421\n", " -1\n", " NaN\n", - " 344.119874\n", + " 398.910421\n", " \n", " \n", - " 2020-10-02\n", - " 331.7000\n", - " 337.0126\n", - " 331.1900\n", - " 333.8400\n", - " 89431112.0\n", - " 333.124901\n", - " 334.199576\n", - " 0.901229\n", - " 49.357005\n", - " 344.119874\n", + " 2021-03-19\n", + " 389.8800\n", + " 391.5690\n", + " 387.1500\n", + " 389.4800\n", + " 113624490.0\n", + " 391.882540\n", + " 389.378690\n", + " 1.055380\n", + " 51.385705\n", + " 398.910421\n", " -1\n", " NaN\n", - " 344.119874\n", + " 398.910421\n", " \n", " \n", "\n", - "

5265 rows × 13 columns

\n", + "

5380 rows × 13 columns

\n", "" ], "text/plain": [ @@ -1308,11 +1579,11 @@ "1999-11-04 136.7500 137.3593 135.7656 136.5312 7907500.0 NaN \n", "1999-11-05 138.6250 139.1093 136.7812 137.8750 7431500.0 NaN \n", "... ... ... ... ... ... ... \n", - "2020-09-28 333.2200 334.9600 332.1500 334.1900 64584614.0 330.408828 \n", - "2020-09-29 333.9700 334.7700 331.6209 332.3700 51531594.0 330.844644 \n", - "2020-09-30 333.0900 338.2900 332.8800 334.8900 104081136.0 331.743612 \n", - "2020-10-01 337.6900 338.7400 335.0100 337.0400 88698745.0 332.920587 \n", - "2020-10-02 331.7000 337.0126 331.1900 333.8400 89431112.0 333.124901 \n", + "2021-03-15 394.3300 396.6850 392.0300 396.4100 73592302.0 390.405499 \n", + "2021-03-16 397.0700 397.8300 395.0800 395.9100 73722506.0 391.628722 \n", + "2021-03-17 394.5300 398.1200 393.3000 397.2600 97959265.0 392.880117 \n", + "2021-03-18 394.4750 396.7200 390.7500 391.4800 115349101.0 392.568980 \n", + "2021-03-19 389.8800 391.5690 387.1500 389.4800 113624490.0 391.882540 \n", "\n", " EMA_21 CUMLOGRET_1 RSI_14 SUPERT_7_3.0 SUPERTd_7_3.0 \\\n", "date \n", @@ -1322,11 +1593,11 @@ "1999-11-04 NaN 0.007120 NaN NaN 1 \n", "1999-11-05 NaN 0.016915 NaN NaN 1 \n", "... ... ... ... ... ... \n", - "2020-09-28 334.010756 0.902277 49.833349 344.119874 -1 \n", - "2020-09-29 333.861596 0.896816 48.051629 344.119874 -1 \n", - "2020-09-30 333.955087 0.904369 50.680975 344.119874 -1 \n", - "2020-10-01 334.235534 0.910769 52.872627 344.119874 -1 \n", - "2020-10-02 334.199576 0.901229 49.357005 344.119874 -1 \n", + "2021-03-15 387.590872 1.073016 61.444065 398.910421 -1 \n", + "2021-03-16 388.347156 1.071754 60.730184 398.910421 -1 \n", + "2021-03-17 389.157415 1.075158 62.013471 398.910421 -1 \n", + "2021-03-18 389.368559 1.060502 53.893084 398.910421 -1 \n", + "2021-03-19 389.378690 1.055380 51.385705 398.910421 -1 \n", "\n", " SUPERTl_7_3.0 SUPERTs_7_3.0 \n", "date \n", @@ -1336,16 +1607,16 @@ "1999-11-04 NaN NaN \n", "1999-11-05 NaN NaN \n", "... ... ... \n", - "2020-09-28 NaN 344.119874 \n", - "2020-09-29 NaN 344.119874 \n", - "2020-09-30 NaN 344.119874 \n", - "2020-10-01 NaN 344.119874 \n", - "2020-10-02 NaN 344.119874 \n", + "2021-03-15 NaN 398.910421 \n", + "2021-03-16 NaN 398.910421 \n", + "2021-03-17 NaN 398.910421 \n", + "2021-03-18 NaN 398.910421 \n", + "2021-03-19 NaN 398.910421 \n", "\n", - "[5265 rows x 13 columns]" + "[5380 rows x 13 columns]" ] }, - "execution_count": 17, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } @@ -1363,16 +1634,16 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "Strategy(name='Runtime Failure', ta=[{'kind': 'percet_return'}], description='TA Description', created='01/23/2021, 12:36:24')" + "Strategy(name='Runtime Failure', ta=[{'kind': 'percet_return'}], description='TA Description', created='Saturday March 20, 2021, NYSE: 13:13:10, Local: 17:13:10 PDT, Day 79/365 (22.0%)')" ] }, - "execution_count": 18, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" } @@ -1385,14 +1656,14 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 20, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[i] Loaded['D']: IWM_D.csv\n", + "[i] Loaded IWM[D]: IWM_D.csv\n", "[X] Oops! 'AnalysisIndicators' object has no attribute 'percet_return'\n" ] } @@ -1429,16 +1700,16 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 21, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "Strategy(name='Volume MAs and Price MA chain', ta=[{'kind': 'ema', 'close': 'volume', 'length': 10, 'prefix': 'VOLUME'}, {'kind': 'sma', 'close': 'volume', 'length': 20, 'prefix': 'VOLUME'}, {'kind': 'ema', 'length': 5}, {'kind': 'linreg', 'close': 'EMA_5', 'length': 8, 'prefix': 'EMA_5'}], description='TA Description', created='01/23/2021, 12:36:24')" + "Strategy(name='Volume MAs and Price MA chain', ta=[{'kind': 'ema', 'close': 'volume', 'length': 10, 'prefix': 'VOLUME'}, {'kind': 'sma', 'close': 'volume', 'length': 20, 'prefix': 'VOLUME'}, {'kind': 'ema', 'length': 5}, {'kind': 'linreg', 'close': 'EMA_5', 'length': 8, 'prefix': 'EMA_5'}], description='TA Description', created='Saturday March 20, 2021, NYSE: 13:13:10, Local: 17:13:10 PDT, Day 79/365 (22.0%)')" ] }, - "execution_count": 20, + "execution_count": 21, "metadata": {}, "output_type": "execute_result" } @@ -1458,7 +1729,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 22, "metadata": {}, "outputs": [ { @@ -1467,7 +1738,7 @@ "'Volume MAs and Price MA chain'" ] }, - "execution_count": 21, + "execution_count": 22, "metadata": {}, "output_type": "execute_result" } @@ -1480,14 +1751,14 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 23, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[i] Loaded['D']: SPY_D.csv\n" + "[i] Loaded SPY[D]: SPY_D.csv\n" ] }, { @@ -1608,68 +1879,68 @@ " ...\n", " \n", " \n", - " 2020-09-28\n", - " 333.2200\n", - " 334.9600\n", - " 332.1500\n", - " 334.1900\n", - " 64584614.0\n", - " 7.861837e+07\n", - " 86281647.00\n", - " 329.781966\n", - " 327.921896\n", + " 2021-03-15\n", + " 394.3300\n", + " 396.6850\n", + " 392.0300\n", + " 396.4100\n", + " 73592302.0\n", + " 9.820634e+07\n", + " 9.988408e+07\n", + " 392.322958\n", + " 389.839335\n", " \n", " \n", - " 2020-09-29\n", - " 333.9700\n", - " 334.7700\n", - " 331.6209\n", - " 332.3700\n", - " 51531594.0\n", - " 7.369350e+07\n", - " 85553267.55\n", - " 330.644644\n", - " 328.610232\n", + " 2021-03-16\n", + " 397.0700\n", + " 397.8300\n", + " 395.0800\n", + " 395.9100\n", + " 73722506.0\n", + " 9.375474e+07\n", + " 1.010216e+08\n", + " 393.518638\n", + " 391.802334\n", " \n", " \n", - " 2020-09-30\n", - " 333.0900\n", - " 338.2900\n", - " 332.8800\n", - " 334.8900\n", - " 104081136.0\n", - " 7.921853e+07\n", - " 88007358.10\n", - " 332.059763\n", - " 329.854718\n", + " 2021-03-17\n", + " 394.5300\n", + " 398.1200\n", + " 393.3000\n", + " 397.2600\n", + " 97959265.0\n", + " 9.451920e+07\n", + " 1.033322e+08\n", + " 394.765759\n", + " 393.574453\n", " \n", " \n", - " 2020-10-01\n", - " 337.6900\n", - " 338.7400\n", - " 335.0100\n", - " 337.0400\n", - " 88698745.0\n", - " 8.094220e+07\n", - " 88965293.60\n", - " 333.719842\n", - " 331.449495\n", + " 2021-03-18\n", + " 394.4750\n", + " 396.7200\n", + " 390.7500\n", + " 391.4800\n", + " 115349101.0\n", + " 9.830645e+07\n", + " 1.061140e+08\n", + " 393.670506\n", + " 394.215707\n", " \n", " \n", - " 2020-10-02\n", - " 331.7000\n", - " 337.0126\n", - " 331.1900\n", - " 333.8400\n", - " 89431112.0\n", - " 8.248564e+07\n", - " 86036292.75\n", - " 333.759895\n", - " 332.881012\n", + " 2021-03-19\n", + " 389.8800\n", + " 391.5690\n", + " 387.1500\n", + " 389.4800\n", + " 113624490.0\n", + " 1.010915e+08\n", + " 1.076332e+08\n", + " 392.273671\n", + " 393.946701\n", " \n", " \n", "\n", - "

5265 rows × 9 columns

\n", + "

5380 rows × 9 columns

\n", "" ], "text/plain": [ @@ -1681,11 +1952,11 @@ "1999-11-04 136.7500 137.3593 135.7656 136.5312 7907500.0 \n", "1999-11-05 138.6250 139.1093 136.7812 137.8750 7431500.0 \n", "... ... ... ... ... ... \n", - "2020-09-28 333.2200 334.9600 332.1500 334.1900 64584614.0 \n", - "2020-09-29 333.9700 334.7700 331.6209 332.3700 51531594.0 \n", - "2020-09-30 333.0900 338.2900 332.8800 334.8900 104081136.0 \n", - "2020-10-01 337.6900 338.7400 335.0100 337.0400 88698745.0 \n", - "2020-10-02 331.7000 337.0126 331.1900 333.8400 89431112.0 \n", + "2021-03-15 394.3300 396.6850 392.0300 396.4100 73592302.0 \n", + "2021-03-16 397.0700 397.8300 395.0800 395.9100 73722506.0 \n", + "2021-03-17 394.5300 398.1200 393.3000 397.2600 97959265.0 \n", + "2021-03-18 394.4750 396.7200 390.7500 391.4800 115349101.0 \n", + "2021-03-19 389.8800 391.5690 387.1500 389.4800 113624490.0 \n", "\n", " VOLUME_EMA_10 VOLUME_SMA_20 EMA_5 EMA_5_LR_8 \n", "date \n", @@ -1695,16 +1966,16 @@ "1999-11-04 NaN NaN NaN NaN \n", "1999-11-05 NaN NaN 136.012480 NaN \n", "... ... ... ... ... \n", - "2020-09-28 7.861837e+07 86281647.00 329.781966 327.921896 \n", - "2020-09-29 7.369350e+07 85553267.55 330.644644 328.610232 \n", - "2020-09-30 7.921853e+07 88007358.10 332.059763 329.854718 \n", - "2020-10-01 8.094220e+07 88965293.60 333.719842 331.449495 \n", - "2020-10-02 8.248564e+07 86036292.75 333.759895 332.881012 \n", + "2021-03-15 9.820634e+07 9.988408e+07 392.322958 389.839335 \n", + "2021-03-16 9.375474e+07 1.010216e+08 393.518638 391.802334 \n", + "2021-03-17 9.451920e+07 1.033322e+08 394.765759 393.574453 \n", + "2021-03-18 9.830645e+07 1.061140e+08 393.670506 394.215707 \n", + "2021-03-19 1.010915e+08 1.076332e+08 392.273671 393.946701 \n", "\n", - "[5265 rows x 9 columns]" + "[5380 rows x 9 columns]" ] }, - "execution_count": 22, + "execution_count": 23, "metadata": {}, "output_type": "execute_result" } @@ -1730,16 +2001,16 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 24, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "Strategy(name='MACD BBands', ta=[{'kind': 'macd'}, {'kind': 'bbands', 'close': 'MACD_12_26_9', 'length': 20, 'prefix': 'MACD'}], description='BBANDS_20 applied to MACD', created='01/23/2021, 12:36:24')" + "Strategy(name='MACD BBands', ta=[{'kind': 'macd'}, {'kind': 'bbands', 'close': 'MACD_12_26_9', 'length': 20, 'prefix': 'MACD'}], description='BBANDS_20 applied to MACD', created='Saturday March 20, 2021, NYSE: 13:13:10, Local: 17:13:10 PDT, Day 79/365 (22.0%)')" ] }, - "execution_count": 23, + "execution_count": 24, "metadata": {}, "output_type": "execute_result" } @@ -1757,7 +2028,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 25, "metadata": {}, "outputs": [ { @@ -1766,7 +2037,7 @@ "'MACD BBands'" ] }, - "execution_count": 24, + "execution_count": 25, "metadata": {}, "output_type": "execute_result" } @@ -1779,14 +2050,14 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 26, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[i] Loaded['D']: SPY_D.csv\n" + "[i] Loaded SPY[D]: SPY_D.csv\n" ] }, { @@ -1931,83 +2202,83 @@ " ...\n", " \n", " \n", - " 2020-09-28\n", - " 333.2200\n", - " 334.9600\n", - " 332.1500\n", - " 334.1900\n", - " 64584614.0\n", - " -2.475445\n", - " -1.262367\n", - " -1.213078\n", - " -5.034888\n", - " 1.888513\n", - " 8.811913\n", - " 733.211957\n", + " 2021-03-15\n", + " 394.3300\n", + " 396.6850\n", + " 392.0300\n", + " 396.4100\n", + " 73592302.0\n", + " 2.268812\n", + " 0.874720\n", + " 1.394091\n", + " -0.900289\n", + " 2.241715\n", + " 5.383720\n", + " 280.321462\n", " \n", " \n", - " 2020-09-29\n", - " 333.9700\n", - " 334.7700\n", - " 331.6209\n", - " 332.3700\n", - " 51531594.0\n", - " -2.252083\n", - " -0.831203\n", - " -1.420879\n", - " -5.348731\n", - " 1.450066\n", - " 8.248862\n", - " 937.722469\n", + " 2021-03-16\n", + " 397.0700\n", + " 397.8300\n", + " 395.0800\n", + " 395.9100\n", + " 73722506.0\n", + " 2.643863\n", + " 0.999818\n", + " 1.644046\n", + " -0.810546\n", + " 2.142097\n", + " 5.094740\n", + " 275.677819\n", " \n", " \n", - " 2020-09-30\n", - " 333.0900\n", - " 338.2900\n", - " 332.8800\n", - " 334.8900\n", - " 104081136.0\n", - " -1.850393\n", - " -0.343611\n", - " -1.506782\n", - " -5.445367\n", - " 1.019390\n", - " 7.484147\n", - " 1268.357614\n", + " 2021-03-17\n", + " 394.5300\n", + " 398.1200\n", + " 393.3000\n", + " 397.2600\n", + " 97959265.0\n", + " 3.015270\n", + " 1.096979\n", + " 1.918291\n", + " -0.690283\n", + " 2.059061\n", + " 4.808406\n", + " 267.048329\n", " \n", " \n", - " 2020-10-01\n", - " 337.6900\n", - " 338.7400\n", - " 335.0100\n", - " 337.0400\n", - " 88698745.0\n", - " -1.343082\n", - " 0.130960\n", - " -1.474042\n", - " -5.235913\n", - " 0.587945\n", - " 6.411803\n", - " 1981.090096\n", + " 2021-03-18\n", + " 394.4750\n", + " 396.7200\n", + " 390.7500\n", + " 391.4800\n", + " 115349101.0\n", + " 2.810813\n", + " 0.714018\n", + " 2.096795\n", + " -0.562339\n", + " 1.973571\n", + " 4.509482\n", + " 256.986903\n", " \n", " \n", - " 2020-10-02\n", - " 331.7000\n", - " 337.0126\n", - " 331.1900\n", - " 333.8400\n", - " 89431112.0\n", - " -1.185581\n", - " 0.230769\n", - " -1.416350\n", - " -4.926333\n", - " 0.197149\n", - " 5.320631\n", - " 5197.569576\n", + " 2021-03-19\n", + " 389.8800\n", + " 391.5690\n", + " 387.1500\n", + " 389.4800\n", + " 113624490.0\n", + " 2.459050\n", + " 0.289804\n", + " 2.169246\n", + " -0.435212\n", + " 1.881908\n", + " 4.199027\n", + " 246.252186\n", " \n", " \n", "\n", - "

5265 rows × 12 columns

\n", + "

5380 rows × 12 columns

\n", "" ], "text/plain": [ @@ -2019,11 +2290,11 @@ "1999-11-04 136.7500 137.3593 135.7656 136.5312 7907500.0 NaN \n", "1999-11-05 138.6250 139.1093 136.7812 137.8750 7431500.0 NaN \n", "... ... ... ... ... ... ... \n", - "2020-09-28 333.2200 334.9600 332.1500 334.1900 64584614.0 -2.475445 \n", - "2020-09-29 333.9700 334.7700 331.6209 332.3700 51531594.0 -2.252083 \n", - "2020-09-30 333.0900 338.2900 332.8800 334.8900 104081136.0 -1.850393 \n", - "2020-10-01 337.6900 338.7400 335.0100 337.0400 88698745.0 -1.343082 \n", - "2020-10-02 331.7000 337.0126 331.1900 333.8400 89431112.0 -1.185581 \n", + "2021-03-15 394.3300 396.6850 392.0300 396.4100 73592302.0 2.268812 \n", + "2021-03-16 397.0700 397.8300 395.0800 395.9100 73722506.0 2.643863 \n", + "2021-03-17 394.5300 398.1200 393.3000 397.2600 97959265.0 3.015270 \n", + "2021-03-18 394.4750 396.7200 390.7500 391.4800 115349101.0 2.810813 \n", + "2021-03-19 389.8800 391.5690 387.1500 389.4800 113624490.0 2.459050 \n", "\n", " MACDh_12_26_9 MACDs_12_26_9 MACD_BBL_20_2.0 MACD_BBM_20_2.0 \\\n", "date \n", @@ -2033,11 +2304,11 @@ "1999-11-04 NaN NaN NaN NaN \n", "1999-11-05 NaN NaN NaN NaN \n", "... ... ... ... ... \n", - "2020-09-28 -1.262367 -1.213078 -5.034888 1.888513 \n", - "2020-09-29 -0.831203 -1.420879 -5.348731 1.450066 \n", - "2020-09-30 -0.343611 -1.506782 -5.445367 1.019390 \n", - "2020-10-01 0.130960 -1.474042 -5.235913 0.587945 \n", - "2020-10-02 0.230769 -1.416350 -4.926333 0.197149 \n", + "2021-03-15 0.874720 1.394091 -0.900289 2.241715 \n", + "2021-03-16 0.999818 1.644046 -0.810546 2.142097 \n", + "2021-03-17 1.096979 1.918291 -0.690283 2.059061 \n", + "2021-03-18 0.714018 2.096795 -0.562339 1.973571 \n", + "2021-03-19 0.289804 2.169246 -0.435212 1.881908 \n", "\n", " MACD_BBU_20_2.0 MACD_BBB_20_2.0 \n", "date \n", @@ -2047,16 +2318,16 @@ "1999-11-04 NaN NaN \n", "1999-11-05 NaN NaN \n", "... ... ... \n", - "2020-09-28 8.811913 733.211957 \n", - "2020-09-29 8.248862 937.722469 \n", - "2020-09-30 7.484147 1268.357614 \n", - "2020-10-01 6.411803 1981.090096 \n", - "2020-10-02 5.320631 5197.569576 \n", + "2021-03-15 5.383720 280.321462 \n", + "2021-03-16 5.094740 275.677819 \n", + "2021-03-17 4.808406 267.048329 \n", + "2021-03-18 4.509482 256.986903 \n", + "2021-03-19 4.199027 246.252186 \n", "\n", - "[5265 rows x 12 columns]" + "[5380 rows x 12 columns]" ] }, - "execution_count": 25, + "execution_count": 26, "metadata": {}, "output_type": "execute_result" } @@ -2089,16 +2360,16 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 27, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "Strategy(name='Momo, Bands and SMAs and Cumulative Log Returns', ta=[{'kind': 'sma', 'length': 50}, {'kind': 'sma', 'length': 200}, {'kind': 'bbands', 'length': 20}, {'kind': 'macd'}, {'kind': 'rsi'}, {'kind': 'log_return', 'cumulative': True}, {'kind': 'sma', 'close': 'CUMLOGRET_1', 'length': 5, 'suffix': 'CUMLOGRET'}], description='MACD and RSI Momo with BBANDS and SMAs 50 & 200 and Cumulative Log Returns', created='01/23/2021, 12:36:24')" + "Strategy(name='Momo, Bands and SMAs and Cumulative Log Returns', ta=[{'kind': 'sma', 'length': 50}, {'kind': 'sma', 'length': 200}, {'kind': 'bbands', 'length': 20}, {'kind': 'macd'}, {'kind': 'rsi'}, {'kind': 'log_return', 'cumulative': True}, {'kind': 'sma', 'close': 'CUMLOGRET_1', 'length': 5, 'suffix': 'CUMLOGRET'}], description='MACD and RSI Momo with BBANDS and SMAs 50 & 200 and Cumulative Log Returns', created='Saturday March 20, 2021, NYSE: 13:13:10, Local: 17:13:10 PDT, Day 79/365 (22.0%)')" ] }, - "execution_count": 26, + "execution_count": 27, "metadata": {}, "output_type": "execute_result" } @@ -2123,7 +2394,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 28, "metadata": {}, "outputs": [ { @@ -2132,7 +2403,7 @@ "'Momo, Bands and SMAs and Cumulative Log Returns'" ] }, - "execution_count": 27, + "execution_count": 28, "metadata": {}, "output_type": "execute_result" } @@ -2145,14 +2416,14 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 29, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[i] Loaded['D']: SPY_D.csv\n" + "[i] Loaded SPY[D]: SPY_D.csv\n" ] }, { @@ -2223,116 +2494,116 @@ " \n", " \n", " \n", - " 1999-11-01\n", - " 136.5000\n", - " 137.0000\n", - " 135.5625\n", - " 135.5625\n", - " 4006500.0\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", + " 2021-03-15\n", + " 394.330\n", + " 396.685\n", + " 392.03\n", + " 396.41\n", + " 73592302.0\n", + " 383.6352\n", + " 349.25675\n", + " 377.450608\n", + " 387.7385\n", + " 398.026392\n", + " 5.306614\n", + " 2.268812\n", + " 0.874720\n", + " 1.394091\n", + " 61.444065\n", + " 1.073016\n", + " 1.062176\n", " 0\n", " 30\n", " 70\n", " \n", " \n", - " 1999-11-02\n", - " 135.9687\n", - " 137.2500\n", - " 134.5937\n", - " 134.5937\n", - " 6516900.0\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " -0.007172\n", - " NaN\n", + " 2021-03-16\n", + " 397.070\n", + " 397.830\n", + " 395.08\n", + " 395.91\n", + " 73722506.0\n", + " 384.0758\n", + " 349.71470\n", + " 377.199689\n", + " 387.9190\n", + " 398.638311\n", + " 5.526572\n", + " 2.643863\n", + " 0.999818\n", + " 1.644046\n", + " 60.730184\n", + " 1.071754\n", + " 1.066640\n", " 0\n", " 30\n", " 70\n", " \n", " \n", - " 1999-11-03\n", - " 136.0000\n", - " 136.3750\n", - " 135.1250\n", - " 135.5000\n", - " 7222300.0\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " -0.000461\n", - " NaN\n", + " 2021-03-17\n", + " 394.530\n", + " 398.120\n", + " 393.30\n", + " 397.26\n", + " 97959265.0\n", + " 384.6452\n", + " 350.17325\n", + " 376.843518\n", + " 388.1625\n", + " 399.481482\n", + " 5.832084\n", + " 3.015270\n", + " 1.096979\n", + " 1.918291\n", + " 62.013471\n", + " 1.075158\n", + " 1.070545\n", " 0\n", " 30\n", " 70\n", " \n", " \n", - " 1999-11-04\n", - " 136.7500\n", - " 137.3593\n", - " 135.7656\n", - " 136.5312\n", - " 7907500.0\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " 0.007120\n", - " NaN\n", + " 2021-03-18\n", + " 394.475\n", + " 396.720\n", + " 390.75\n", + " 391.48\n", + " 115349101.0\n", + " 385.0482\n", + " 350.59025\n", + " 376.842394\n", + " 388.2005\n", + " 399.558606\n", + " 5.851670\n", + " 2.810813\n", + " 0.714018\n", + " 2.096795\n", + " 53.893084\n", + " 1.060502\n", + " 1.069500\n", " 0\n", " 30\n", " 70\n", " \n", " \n", - " 1999-11-05\n", - " 138.6250\n", - " 139.1093\n", - " 136.7812\n", - " 137.8750\n", - " 7431500.0\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " 0.016915\n", - " NaN\n", + " 2021-03-19\n", + " 389.880\n", + " 391.569\n", + " 387.15\n", + " 389.48\n", + " 113624490.0\n", + " 385.3668\n", + " 350.97675\n", + " 376.830092\n", + " 388.1730\n", + " 399.515908\n", + " 5.844254\n", + " 2.459050\n", + " 0.289804\n", + " 2.169246\n", + " 51.385705\n", + " 1.055380\n", + " 1.067162\n", " 0\n", " 30\n", " 70\n", @@ -2342,40 +2613,40 @@ "" ], "text/plain": [ - " open high low close volume SMA_50 \\\n", - "date \n", - "1999-11-01 136.5000 137.0000 135.5625 135.5625 4006500.0 NaN \n", - "1999-11-02 135.9687 137.2500 134.5937 134.5937 6516900.0 NaN \n", - "1999-11-03 136.0000 136.3750 135.1250 135.5000 7222300.0 NaN \n", - "1999-11-04 136.7500 137.3593 135.7656 136.5312 7907500.0 NaN \n", - "1999-11-05 138.6250 139.1093 136.7812 137.8750 7431500.0 NaN \n", - "\n", - " SMA_200 BBL_20_2.0 BBM_20_2.0 BBU_20_2.0 BBB_20_2.0 \\\n", + " open high low close volume SMA_50 \\\n", "date \n", - "1999-11-01 NaN NaN NaN NaN NaN \n", - "1999-11-02 NaN NaN NaN NaN NaN \n", - "1999-11-03 NaN NaN NaN NaN NaN \n", - "1999-11-04 NaN NaN NaN NaN NaN \n", - "1999-11-05 NaN NaN NaN NaN NaN \n", + "2021-03-15 394.330 396.685 392.03 396.41 73592302.0 383.6352 \n", + "2021-03-16 397.070 397.830 395.08 395.91 73722506.0 384.0758 \n", + "2021-03-17 394.530 398.120 393.30 397.26 97959265.0 384.6452 \n", + "2021-03-18 394.475 396.720 390.75 391.48 115349101.0 385.0482 \n", + "2021-03-19 389.880 391.569 387.15 389.48 113624490.0 385.3668 \n", "\n", - " MACD_12_26_9 MACDh_12_26_9 MACDs_12_26_9 RSI_14 CUMLOGRET_1 \\\n", - "date \n", - "1999-11-01 NaN NaN NaN NaN NaN \n", - "1999-11-02 NaN NaN NaN NaN -0.007172 \n", - "1999-11-03 NaN NaN NaN NaN -0.000461 \n", - "1999-11-04 NaN NaN NaN NaN 0.007120 \n", - "1999-11-05 NaN NaN NaN NaN 0.016915 \n", + " SMA_200 BBL_20_2.0 BBM_20_2.0 BBU_20_2.0 BBB_20_2.0 \\\n", + "date \n", + "2021-03-15 349.25675 377.450608 387.7385 398.026392 5.306614 \n", + "2021-03-16 349.71470 377.199689 387.9190 398.638311 5.526572 \n", + "2021-03-17 350.17325 376.843518 388.1625 399.481482 5.832084 \n", + "2021-03-18 350.59025 376.842394 388.2005 399.558606 5.851670 \n", + "2021-03-19 350.97675 376.830092 388.1730 399.515908 5.844254 \n", "\n", - " SMA_5_CUMLOGRET 0 30 70 \n", - "date \n", - "1999-11-01 NaN 0 30 70 \n", - "1999-11-02 NaN 0 30 70 \n", - "1999-11-03 NaN 0 30 70 \n", - "1999-11-04 NaN 0 30 70 \n", - "1999-11-05 NaN 0 30 70 " + " MACD_12_26_9 MACDh_12_26_9 MACDs_12_26_9 RSI_14 \\\n", + "date \n", + "2021-03-15 2.268812 0.874720 1.394091 61.444065 \n", + "2021-03-16 2.643863 0.999818 1.644046 60.730184 \n", + "2021-03-17 3.015270 1.096979 1.918291 62.013471 \n", + "2021-03-18 2.810813 0.714018 2.096795 53.893084 \n", + "2021-03-19 2.459050 0.289804 2.169246 51.385705 \n", + "\n", + " CUMLOGRET_1 SMA_5_CUMLOGRET 0 30 70 \n", + "date \n", + "2021-03-15 1.073016 1.062176 0 30 70 \n", + "2021-03-16 1.071754 1.066640 0 30 70 \n", + "2021-03-17 1.075158 1.070545 0 30 70 \n", + "2021-03-18 1.060502 1.069500 0 30 70 \n", + "2021-03-19 1.055380 1.067162 0 30 70 " ] }, - "execution_count": 28, + "execution_count": 29, "metadata": {}, "output_type": "execute_result" } @@ -2384,7 +2655,7 @@ "spy = watch.load(\"SPY\")\n", "# Apply constants to the DataFrame for indicators\n", "spy.ta.constants(True, [0, 30, 70])\n", - "spy.head()" + "spy.tail()" ] }, { @@ -2413,16 +2684,16 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 30, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "Strategy(name='EMA, MACD History, Outter BBands, Log Returns', ta=[{'kind': 'ema', 'params': (10,)}, {'kind': 'macd', 'params': (9, 19, 10), 'col_numbers': (1,)}, {'kind': 'bbands', 'col_numbers': (0, 2), 'col_names': ('LB', 'UB')}, {'kind': 'log_return', 'params': (5, False)}], description='EMA, MACD History, BBands(LB, UB), and Log Returns Strategy', created='01/23/2021, 12:36:24')" + "Strategy(name='EMA, MACD History, Outter BBands, Log Returns', ta=[{'kind': 'ema', 'params': (10,)}, {'kind': 'macd', 'params': (9, 19, 10), 'col_numbers': (1,)}, {'kind': 'bbands', 'col_numbers': (0, 2), 'col_names': ('LB', 'UB')}, {'kind': 'log_return', 'params': (5, False)}], description='EMA, MACD History, BBands(LB, UB), and Log Returns Strategy', created='Saturday March 20, 2021, NYSE: 13:13:10, Local: 17:13:10 PDT, Day 79/365 (22.0%)')" ] }, - "execution_count": 29, + "execution_count": 30, "metadata": {}, "output_type": "execute_result" } @@ -2447,7 +2718,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 31, "metadata": {}, "outputs": [ { @@ -2456,7 +2727,7 @@ "'EMA, MACD History, Outter BBands, Log Returns'" ] }, - "execution_count": 30, + "execution_count": 31, "metadata": {}, "output_type": "execute_result" } @@ -2469,14 +2740,14 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 32, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[i] Loaded['D']: SPY_D.csv\n" + "[i] Loaded SPY[D]: SPY_D.csv\n" ] }, { @@ -2527,93 +2798,93 @@ " \n", " \n", " \n", - " 2020-09-28\n", - " 333.22\n", - " 334.9600\n", - " 332.1500\n", - " 334.19\n", - " 64584614.0\n", - " 331.135274\n", - " -0.761769\n", - " 318.226448\n", - " 337.517552\n", - " 0.021841\n", + " 2021-03-15\n", + " 394.330\n", + " 396.685\n", + " 392.03\n", + " 396.41\n", + " 73592302.0\n", + " 389.640175\n", + " 1.360361\n", + " 385.510398\n", + " 398.789602\n", + " 0.037762\n", " \n", " \n", - " 2020-09-29\n", - " 333.97\n", - " 334.7700\n", - " 331.6209\n", - " 332.37\n", - " 51531594.0\n", - " 331.359770\n", - " -0.249828\n", - " 317.965316\n", - " 338.606684\n", - " 0.006247\n", + " 2021-03-16\n", + " 397.070\n", + " 397.830\n", + " 395.08\n", + " 395.91\n", + " 73722506.0\n", + " 390.780143\n", + " 1.425897\n", + " 389.067672\n", + " 398.728328\n", + " 0.022323\n", " \n", " \n", - " 2020-09-30\n", - " 333.09\n", - " 338.2900\n", - " 332.8800\n", - " 334.89\n", - " 104081136.0\n", - " 332.001630\n", - " 0.311580\n", - " 321.342411\n", - " 340.129589\n", - " 0.037265\n", + " 2021-03-17\n", + " 394.530\n", + " 398.120\n", + " 393.30\n", + " 397.26\n", + " 97959265.0\n", + " 391.958299\n", + " 1.461750\n", + " 392.601825\n", + " 398.266175\n", + " 0.019522\n", " \n", " \n", - " 2020-10-01\n", - " 337.69\n", - " 338.7400\n", - " 335.0100\n", - " 337.04\n", - " 88698745.0\n", - " 332.917697\n", - " 0.832955\n", - " 327.202692\n", - " 339.685308\n", - " 0.041003\n", + " 2021-03-18\n", + " 394.475\n", + " 396.720\n", + " 390.75\n", + " 391.48\n", + " 115349101.0\n", + " 391.871336\n", + " 0.889025\n", + " 390.906241\n", + " 399.141759\n", + " -0.005223\n", " \n", " \n", - " 2020-10-02\n", - " 331.70\n", - " 337.0126\n", - " 331.1900\n", - " 333.84\n", - " 89431112.0\n", - " 333.085389\n", - " 0.854917\n", - " 331.050371\n", - " 337.881629\n", - " 0.015425\n", + " 2021-03-19\n", + " 389.880\n", + " 391.569\n", + " 387.15\n", + " 389.48\n", + " 113624490.0\n", + " 391.436547\n", + " 0.302361\n", + " 387.988766\n", + " 400.227234\n", + " -0.011691\n", " \n", " \n", "\n", "" ], "text/plain": [ - " open high low close volume EMA_10 \\\n", - "date \n", - "2020-09-28 333.22 334.9600 332.1500 334.19 64584614.0 331.135274 \n", - "2020-09-29 333.97 334.7700 331.6209 332.37 51531594.0 331.359770 \n", - "2020-09-30 333.09 338.2900 332.8800 334.89 104081136.0 332.001630 \n", - "2020-10-01 337.69 338.7400 335.0100 337.04 88698745.0 332.917697 \n", - "2020-10-02 331.70 337.0126 331.1900 333.84 89431112.0 333.085389 \n", + " open high low close volume EMA_10 \\\n", + "date \n", + "2021-03-15 394.330 396.685 392.03 396.41 73592302.0 389.640175 \n", + "2021-03-16 397.070 397.830 395.08 395.91 73722506.0 390.780143 \n", + "2021-03-17 394.530 398.120 393.30 397.26 97959265.0 391.958299 \n", + "2021-03-18 394.475 396.720 390.75 391.48 115349101.0 391.871336 \n", + "2021-03-19 389.880 391.569 387.15 389.48 113624490.0 391.436547 \n", "\n", " MACDh_9_19_10 LB UB LOGRET_5 \n", "date \n", - "2020-09-28 -0.761769 318.226448 337.517552 0.021841 \n", - "2020-09-29 -0.249828 317.965316 338.606684 0.006247 \n", - "2020-09-30 0.311580 321.342411 340.129589 0.037265 \n", - "2020-10-01 0.832955 327.202692 339.685308 0.041003 \n", - "2020-10-02 0.854917 331.050371 337.881629 0.015425 " + "2021-03-15 1.360361 385.510398 398.789602 0.037762 \n", + "2021-03-16 1.425897 389.067672 398.728328 0.022323 \n", + "2021-03-17 1.461750 392.601825 398.266175 0.019522 \n", + "2021-03-18 0.889025 390.906241 399.141759 -0.005223 \n", + "2021-03-19 0.302361 387.988766 400.227234 -0.011691 " ] }, - "execution_count": 31, + "execution_count": 32, "metadata": {}, "output_type": "execute_result" } @@ -2622,6 +2893,23 @@ "spy = watch.load(\"SPY\")\n", "spy.tail()" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Disclaimer\n", + "* All investments involve risk, and the past performance of a security, industry, sector, market, financial product, trading strategy, or individual’s trading does not guarantee future results or returns. Investors are fully responsible for any investment decisions they make. Such decisions should be based solely on an evaluation of their financial circumstances, investment objectives, risk tolerance, and liquidity needs.\n", + "\n", + "* Any opinions, news, research, analyses, prices, or other information offered is provided as general market commentary, and does not constitute investment advice. I will not accept liability for any loss or damage, including without limitation any loss of profit, which may arise directly or indirectly from use of or reliance on such information." + ] } ], "metadata": { @@ -2640,7 +2928,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.2" + "version": "3.9.1" } }, "nbformat": 4, diff --git a/examples/example.ipynb b/examples/example.ipynb index 0accb8d..98f3956 100644 --- a/examples/example.ipynb +++ b/examples/example.ipynb @@ -19,6 +19,11 @@ "name": "stdout", "output_type": "stream", "text": [ + "\n", + "Pandas TA v0.2.49b0\n", + "To install the Latest Version:\n", + "$ pip install -U git+https://github.com/twopirllc/pandas-ta\n", + "\n", "Populating the interactive namespace from numpy and matplotlib\n" ] } @@ -36,9 +41,10 @@ "import pandas_ta as ta\n", "\n", "from watchlist import colors # Is this failing? If so, copy it locally. See above.\n", - "%pylab inline\n", "\n", - "e = pd.DataFrame()" + "print(f\"\\nPandas TA v{ta.version}\\nTo install the Latest Version:\\n$ pip install -U git+https://github.com/twopirllc/pandas-ta\\n\")\n", + "\n", + "%pylab inline" ] }, { @@ -57,14 +63,15 @@ "name": "stdout", "output_type": "stream", "text": [ - "Pandas TA - Technical Analysis Indicators - v0.2.40b0\n", - "Total Indicators: 129\n", + "Pandas TA - Technical Analysis Indicators - v0.2.49b0\n", + "Total Indicators: 133\n", "Abbreviations:\n", - " aberration, above, above_value, accbands, ad, adosc, adx, amat, ao, aobv, apo, aroon, atr, bbands, below, below_value, bias, bop, brar, cci, cdl_doji, cdl_inside, cfo, cg, chop, cksp, cmf, cmo, coppock, cross, cross_value, decay, decreasing, dema, donchian, dpo, efi, ema, entropy, eom, er, eri, fisher, fwma, ha, hilo, hl2, hlc3, hma, ichimoku, increasing, inertia, kama, kc, kdj, kst, kurtosis, linreg, log_return, long_run, macd, mad, massi, mcgd, median, mfi, midpoint, midprice, mom, natr, nvi, obv, ohlc4, pdist, percent_return, pgo, ppo, psar, psl, pvi, pvo, pvol, pvr, pvt, pwma, qqe, qstick, quantile, rma, roc, rsi, rsx, rvgi, rvi, short_run, sinwma, skew, slope, sma, smi, squeeze, ssf, stdev, stoch, stochrsi, supertrend, swma, t3, tema, thermo, trend_return, trima, trix, true_range, tsi, ttm_trend, ui, uo, variance, vidya, vortex, vp, vwap, vwma, wcp, willr, wma, zlma, zscore\n" + " aberration, above, above_value, accbands, ad, adosc, adx, alma, amat, ao, aobv, apo, aroon, atr, bbands, below, below_value, bias, bop, brar, cci, cdl_doji, cdl_inside, cfo, cg, chop, cksp, cmf, cmo, coppock, cross, cross_value, decay, decreasing, dema, donchian, dpo, ebsw, efi, ema, entropy, eom, er, eri, fisher, fwma, ha, hilo, hl2, hlc3, hma, hwc, hwma, ichimoku, increasing, inertia, kama, kc, kdj, kst, kurtosis, linreg, log_return, long_run, macd, mad, massi, mcgd, median, mfi, midpoint, midprice, mom, natr, nvi, obv, ohlc4, pdist, percent_return, pgo, ppo, psar, psl, pvi, pvo, pvol, pvr, pvt, pwma, qqe, qstick, quantile, rma, roc, rsi, rsx, rvgi, rvi, short_run, sinwma, skew, slope, sma, smi, squeeze, ssf, stdev, stoch, stochrsi, supertrend, swma, t3, tema, thermo, trend_return, trima, trix, true_range, tsi, ttm_trend, ui, uo, variance, vidya, vortex, vp, vwap, vwma, wcp, willr, wma, zlma, zscore\n" ] } ], "source": [ + "e = pd.DataFrame()\n", "e.ta.indicators()" ] }, @@ -110,8 +117,8 @@ " \n", " Args:\n", " close (pd.Series): Series of 'close's\n", - " length (int): It's period. Default: 10\n", - " offset (int): How many periods to offset the result. Default: 0\n", + " length (int): It's period. Default: 10\n", + " offset (int): How many periods to offset the result. Default: 0\n", " \n", " Kwargs:\n", " adjust (bool, optional): Default: False\n", @@ -205,25 +212,25 @@ "name": "stdout", "output_type": "stream", "text": [ - "SPY(5346, 6) from 1999-11-01 00:00:00 to 2021-01-29 00:00:00\n", + "SPY(5380, 6) from 1999-11-01 00:00:00 to 2021-03-19 00:00:00\n", " open high low close adj_close \\\n", - "count 5346.000000 5346.000000 5346.000000 5346.000000 5346.000000 \n", - "mean 166.015616 166.998063 164.932399 166.013302 141.371190 \n", - "std 68.046206 68.280578 67.772147 68.048026 75.636336 \n", - "min 67.949997 70.000000 67.099998 68.110001 53.467932 \n", - "25% 116.952500 117.650000 115.962499 116.782500 87.064387 \n", - "50% 139.294998 140.250000 138.060005 139.290604 106.452979 \n", - "75% 207.260000 208.262501 206.192500 207.437498 186.563804 \n", - "max 385.410000 385.850000 383.540000 384.390000 384.390000 \n", + "count 5380.000000 5380.000000 5380.000000 5380.000000 5380.000000 \n", + "mean 167.419155 168.409715 166.323628 167.417051 142.463502 \n", + "std 70.078338 70.329842 69.775798 70.080913 77.639141 \n", + "min 67.949997 70.000000 67.099998 68.110001 53.293084 \n", + "25% 117.075001 117.750000 116.134999 116.952501 86.863564 \n", + "50% 139.650000 140.485000 138.380002 139.619998 106.414197 \n", + "75% 207.895001 208.862500 206.962505 208.000000 186.493235 \n", + "max 397.070000 398.120000 395.080000 397.260000 395.960950 \n", "\n", " volume \n", - "count 5.346000e+03 \n", - "mean 1.105581e+08 \n", - "std 9.729803e+07 \n", + "count 5.380000e+03 \n", + "mean 1.104003e+08 \n", + "std 9.705407e+07 \n", "min 1.708170e+05 \n", - "25% 4.799383e+07 \n", - "50% 8.158458e+07 \n", - "75% 1.473309e+08 \n", + "25% 4.816881e+07 \n", + "50% 8.150983e+07 \n", + "75% 1.470993e+08 \n", "max 8.710263e+08 \n" ] }, @@ -272,7 +279,7 @@ " 137.000000\n", " 135.562500\n", " 135.562500\n", - " 91.209278\n", + " 90.911009\n", " 4006500.0\n", " \n", " \n", @@ -281,7 +288,7 @@ " 137.250000\n", " 134.593704\n", " 134.593704\n", - " 90.557452\n", + " 90.261314\n", " 6516900.0\n", " \n", " \n", @@ -290,7 +297,7 @@ " 136.375000\n", " 135.125000\n", " 135.500000\n", - " 91.167226\n", + " 90.869095\n", " 7222300.0\n", " \n", " \n", @@ -299,7 +306,7 @@ " 137.359299\n", " 135.765594\n", " 136.531204\n", - " 91.861042\n", + " 91.560642\n", " 7907500.0\n", " \n", " \n", @@ -308,7 +315,7 @@ " 139.109299\n", " 136.781204\n", " 137.875000\n", - " 92.765176\n", + " 92.461819\n", " 7431500.0\n", " \n", " \n", @@ -318,11 +325,11 @@ "text/plain": [ " open high low close adj_close \\\n", "date \n", - "1999-11-01 136.500000 137.000000 135.562500 135.562500 91.209278 \n", - "1999-11-02 135.968704 137.250000 134.593704 134.593704 90.557452 \n", - "1999-11-03 136.000000 136.375000 135.125000 135.500000 91.167226 \n", - "1999-11-04 136.750000 137.359299 135.765594 136.531204 91.861042 \n", - "1999-11-05 138.625000 139.109299 136.781204 137.875000 92.765176 \n", + "1999-11-01 136.500000 137.000000 135.562500 135.562500 90.911009 \n", + "1999-11-02 135.968704 137.250000 134.593704 134.593704 90.261314 \n", + "1999-11-03 136.000000 136.375000 135.125000 135.500000 90.869095 \n", + "1999-11-04 136.750000 137.359299 135.765594 136.531204 91.560642 \n", + "1999-11-05 138.625000 139.109299 136.781204 137.875000 92.461819 \n", "\n", " volume \n", "date \n", @@ -354,25 +361,25 @@ "name": "stdout", "output_type": "stream", "text": [ - "SPY(252, 6) from 2020-01-31 00:00:00 to 2021-01-29 00:00:00\n", + "SPY(252, 6) from 2020-03-20 00:00:00 to 2021-03-19 00:00:00\n", " open high low close adj_close \\\n", - "count 5346.000000 5346.000000 5346.000000 5346.000000 5346.000000 \n", - "mean 166.015616 166.998063 164.932399 166.013302 141.371190 \n", - "std 68.046206 68.280578 67.772147 68.048026 75.636336 \n", - "min 67.949997 70.000000 67.099998 68.110001 53.467932 \n", - "25% 116.952500 117.650000 115.962499 116.782500 87.064387 \n", - "50% 139.294998 140.250000 138.060005 139.290604 106.452979 \n", - "75% 207.260000 208.262501 206.192500 207.437498 186.563804 \n", - "max 385.410000 385.850000 383.540000 384.390000 384.390000 \n", + "count 5380.000000 5380.000000 5380.000000 5380.000000 5380.000000 \n", + "mean 167.419155 168.409715 166.323628 167.417051 142.463502 \n", + "std 70.078338 70.329842 69.775798 70.080913 77.639141 \n", + "min 67.949997 70.000000 67.099998 68.110001 53.293084 \n", + "25% 117.075001 117.750000 116.134999 116.952501 86.863564 \n", + "50% 139.650000 140.485000 138.380002 139.619998 106.414197 \n", + "75% 207.895001 208.862500 206.962505 208.000000 186.493235 \n", + "max 397.070000 398.120000 395.080000 397.260000 395.960950 \n", "\n", " volume \n", - "count 5.346000e+03 \n", - "mean 1.105581e+08 \n", - "std 9.729803e+07 \n", + "count 5.380000e+03 \n", + "mean 1.104003e+08 \n", + "std 9.705407e+07 \n", "min 1.708170e+05 \n", - "25% 4.799383e+07 \n", - "50% 8.158458e+07 \n", - "75% 1.473309e+08 \n", + "25% 4.816881e+07 \n", + "50% 8.150983e+07 \n", + "75% 1.470993e+08 \n", "max 8.710263e+08 \n" ] }, @@ -416,49 +423,49 @@ " \n", " \n", " \n", - " 2020-01-31\n", - " 327.00\n", - " 327.17\n", - " 320.73\n", - " 321.73\n", - " 315.720975\n", - " 113659402.0\n", + " 2020-03-20\n", + " 242.53\n", + " 244.47\n", + " 228.50\n", + " 228.80\n", + " 225.167208\n", + " 344276957.0\n", " \n", " \n", - " 2020-02-03\n", - " 323.35\n", - " 326.16\n", - " 323.22\n", - " 324.12\n", - " 318.066336\n", - " 68931216.0\n", + " 2020-03-23\n", + " 228.19\n", + " 229.68\n", + " 218.26\n", + " 222.95\n", + " 219.410092\n", + " 323100167.0\n", " \n", " \n", - " 2020-02-04\n", - " 328.07\n", - " 330.01\n", - " 327.72\n", - " 329.06\n", - " 322.914071\n", - " 61704740.0\n", + " 2020-03-24\n", + " 234.42\n", + " 244.10\n", + " 233.80\n", + " 243.15\n", + " 239.289365\n", + " 233038623.0\n", " \n", " \n", - " 2020-02-05\n", - " 332.27\n", - " 333.09\n", - " 330.67\n", - " 332.86\n", - " 326.643097\n", - " 64864742.0\n", + " 2020-03-25\n", + " 244.87\n", + " 256.35\n", + " 239.75\n", + " 246.79\n", + " 242.871570\n", + " 297989659.0\n", " \n", " \n", - " 2020-02-06\n", - " 333.91\n", - " 334.19\n", - " 332.80\n", - " 333.98\n", - " 327.742179\n", - " 49982975.0\n", + " 2020-03-26\n", + " 249.52\n", + " 262.80\n", + " 249.05\n", + " 261.20\n", + " 257.052774\n", + " 256107410.0\n", " \n", " \n", "\n", @@ -467,11 +474,11 @@ "text/plain": [ " open high low close adj_close volume\n", "date \n", - "2020-01-31 327.00 327.17 320.73 321.73 315.720975 113659402.0\n", - "2020-02-03 323.35 326.16 323.22 324.12 318.066336 68931216.0\n", - "2020-02-04 328.07 330.01 327.72 329.06 322.914071 61704740.0\n", - "2020-02-05 332.27 333.09 330.67 332.86 326.643097 64864742.0\n", - "2020-02-06 333.91 334.19 332.80 333.98 327.742179 49982975.0" + "2020-03-20 242.53 244.47 228.50 228.80 225.167208 344276957.0\n", + "2020-03-23 228.19 229.68 218.26 222.95 219.410092 323100167.0\n", + "2020-03-24 234.42 244.10 233.80 243.15 239.289365 233038623.0\n", + "2020-03-25 244.87 256.35 239.75 246.79 242.871570 297989659.0\n", + "2020-03-26 249.52 262.80 249.05 261.20 257.052774 256107410.0" ] }, "execution_count": 7, @@ -913,17 +920,18 @@ "name": "stdout", "output_type": "stream", "text": [ - "[i] Loaded SPY(5346, 33)\n", + "[i] Loaded SPY(5380, 33)\n", "[+] Strategy: Common Price and Volume SMAs\n", "[i] Indicator arguments: {'append': True}\n", - "[i] Multiprocessing: 8 of 8 cores.\n", + "[i] Multiprocessing 5 indicators with 7 chunks over 8/8 cpus.\n", "[i] Total indicators: 5\n", - "[i] Columns added: 5\n" + "[i] Columns added: 5\n", + "[i] Last Run: Saturday March 20, 2021, NYSE: 13:11:58, Local: 17:11:58 PDT, Day 79/365 (22.0%)\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -936,17 +944,17 @@ "output_type": "stream", "text": [ "\n", - "Pandas v: 1.2.0 [pip install pandas] https://github.com/pandas-dev/pandas\n", + "Pandas v: 1.2.2 [pip install pandas] https://github.com/pandas-dev/pandas\n", "Data from AlphaVantage v: 1.0.19 [pip install alphaVantage-api] http://www.alphavantage.co https://github.com/twopirllc/AlphaVantageAPI\n", - "Technical Analysis with Pandas TA v: 0.2.40b0 [pip install pandas_ta] https://github.com/twopirllc/pandas-ta\n", - "Charts by Matplotlib Finance v: 0.12.7a4 [pip install mplfinance] https://github.com/matplotlib/mplfinance\n", + "Technical Analysis with Pandas TA v: 0.2.49b0 [pip install pandas_ta] https://github.com/twopirllc/pandas-ta\n", + "Charts by Matplotlib Finance v: 0.12.7a5 [pip install mplfinance] https://github.com/matplotlib/mplfinance\n", "\n" ] }, { "data": { "text/plain": [ - "<__main__.Chart at 0x10be11370>" + "<__main__.Chart at 0x10c73c5b0>" ] }, "execution_count": 11, @@ -1015,7 +1023,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 12, @@ -1024,7 +1032,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1056,7 +1064,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 13, @@ -1065,7 +1073,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1092,18 +1100,10 @@ "execution_count": 14, "metadata": {}, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "variance.ddof: 1\n" - ] - }, { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 14, @@ -1112,7 +1112,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1133,18 +1133,10 @@ "execution_count": 15, "metadata": {}, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "variance.ddof: 1\n" - ] - }, { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 15, @@ -1153,7 +1145,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1199,17 +1191,9 @@ "execution_count": 17, "metadata": {}, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "variance.ddof: 1\n" - ] - }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1222,17 +1206,17 @@ "output_type": "stream", "text": [ "\n", - "Pandas v: 1.2.0 [pip install pandas] https://github.com/pandas-dev/pandas\n", + "Pandas v: 1.2.2 [pip install pandas] https://github.com/pandas-dev/pandas\n", "Data from AlphaVantage v: 1.0.19 [pip install alphaVantage-api] http://www.alphavantage.co https://github.com/twopirllc/AlphaVantageAPI\n", - "Technical Analysis with Pandas TA v: 0.2.40b0 [pip install pandas_ta] https://github.com/twopirllc/pandas-ta\n", - "Charts by Matplotlib Finance v: 0.12.7a4 [pip install mplfinance] https://github.com/matplotlib/mplfinance\n", + "Technical Analysis with Pandas TA v: 0.2.49b0 [pip install pandas_ta] https://github.com/twopirllc/pandas-ta\n", + "Charts by Matplotlib Finance v: 0.12.7a5 [pip install mplfinance] https://github.com/matplotlib/mplfinance\n", "\n" ] }, { "data": { "text/plain": [ - "<__main__.Chart at 0x15d7dfe50>" + "<__main__.Chart at 0x12f593e20>" ] }, "execution_count": 17, @@ -1259,17 +1243,9 @@ "execution_count": 18, "metadata": {}, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "variance.ddof: 1\n" - ] - }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1282,17 +1258,17 @@ "output_type": "stream", "text": [ "\n", - "Pandas v: 1.2.0 [pip install pandas] https://github.com/pandas-dev/pandas\n", + "Pandas v: 1.2.2 [pip install pandas] https://github.com/pandas-dev/pandas\n", "Data from AlphaVantage v: 1.0.19 [pip install alphaVantage-api] http://www.alphavantage.co https://github.com/twopirllc/AlphaVantageAPI\n", - "Technical Analysis with Pandas TA v: 0.2.40b0 [pip install pandas_ta] https://github.com/twopirllc/pandas-ta\n", - "Charts by Matplotlib Finance v: 0.12.7a4 [pip install mplfinance] https://github.com/matplotlib/mplfinance\n", + "Technical Analysis with Pandas TA v: 0.2.49b0 [pip install pandas_ta] https://github.com/twopirllc/pandas-ta\n", + "Charts by Matplotlib Finance v: 0.12.7a5 [pip install mplfinance] https://github.com/matplotlib/mplfinance\n", "\n" ] }, { "data": { "text/plain": [ - "<__main__.Chart at 0x15ca275e0>" + "<__main__.Chart at 0x12f383250>" ] }, "execution_count": 18, @@ -1323,7 +1299,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1336,17 +1312,17 @@ "output_type": "stream", "text": [ "\n", - "Pandas v: 1.2.0 [pip install pandas] https://github.com/pandas-dev/pandas\n", + "Pandas v: 1.2.2 [pip install pandas] https://github.com/pandas-dev/pandas\n", "Data from AlphaVantage v: 1.0.19 [pip install alphaVantage-api] http://www.alphavantage.co https://github.com/twopirllc/AlphaVantageAPI\n", - "Technical Analysis with Pandas TA v: 0.2.40b0 [pip install pandas_ta] https://github.com/twopirllc/pandas-ta\n", - "Charts by Matplotlib Finance v: 0.12.7a4 [pip install mplfinance] https://github.com/matplotlib/mplfinance\n", + "Technical Analysis with Pandas TA v: 0.2.49b0 [pip install pandas_ta] https://github.com/twopirllc/pandas-ta\n", + "Charts by Matplotlib Finance v: 0.12.7a5 [pip install mplfinance] https://github.com/matplotlib/mplfinance\n", "\n" ] }, { "data": { "text/plain": [ - "<__main__.Chart at 0x15d767820>" + "<__main__.Chart at 0x12f5064f0>" ] }, "execution_count": 19, @@ -1381,7 +1357,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1394,17 +1370,17 @@ "output_type": "stream", "text": [ "\n", - "Pandas v: 1.2.0 [pip install pandas] https://github.com/pandas-dev/pandas\n", + "Pandas v: 1.2.2 [pip install pandas] https://github.com/pandas-dev/pandas\n", "Data from AlphaVantage v: 1.0.19 [pip install alphaVantage-api] http://www.alphavantage.co https://github.com/twopirllc/AlphaVantageAPI\n", - "Technical Analysis with Pandas TA v: 0.2.40b0 [pip install pandas_ta] https://github.com/twopirllc/pandas-ta\n", - "Charts by Matplotlib Finance v: 0.12.7a4 [pip install mplfinance] https://github.com/matplotlib/mplfinance\n", + "Technical Analysis with Pandas TA v: 0.2.49b0 [pip install pandas_ta] https://github.com/twopirllc/pandas-ta\n", + "Charts by Matplotlib Finance v: 0.12.7a5 [pip install mplfinance] https://github.com/matplotlib/mplfinance\n", "\n" ] }, { "data": { "text/plain": [ - "<__main__.Chart at 0x15db527c0>" + "<__main__.Chart at 0x12fb5d550>" ] }, "execution_count": 20, @@ -1449,7 +1425,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.2" + "version": "3.9.1" } }, "nbformat": 4, diff --git a/examples/watchlist.py b/examples/watchlist.py index b2b31e6..aee3ae6 100644 --- a/examples/watchlist.py +++ b/examples/watchlist.py @@ -3,11 +3,13 @@ import datetime as dt from pathlib import Path from random import random +from typing import Tuple import pandas as pd # pip install pandas +from pandas_datareader import data as pdr import yfinance as yf -# yf.pdr_override() # <== that's all it takes :-) +yf.pdr_override() # <== that's all it takes :-) from numpy import arange as npArange from numpy import append as npAppend @@ -72,14 +74,9 @@ class Watchlist(object): - tickers: A list of strings containing tickers. Example: ["SPY", "AAPL"] """ - def __init__( - self, - tickers: list, - tf: str = None, - name: str = None, - strategy: ta.Strategy = None, - ds: object = None, - **kwargs, + def __init__(self, + tickers: list, tf: str = None, name: str = None, + strategy: ta.Strategy = None, ds_name: str = "av", **kwargs, ): self.verbose = kwargs.pop("verbose", False) self.debug = kwargs.pop("debug", False) @@ -92,24 +89,25 @@ class Watchlist(object): self.kwargs = kwargs self.strategy = strategy - self._init_data_source(ds) + self._init_data_source(ds_name) - def _init_data_source(self, ds: object): - if ds is not None: - self.ds = ds - elif isinstance(ds, str) and ds.lower() == "yahoo": + + def _init_data_source(self, ds: str) -> None: + self.ds_name = ds.lower() if isinstance(ds, str) else "av" + + # Default: AlphaVantage + AVkwargs = {"api_key": "YOUR API KEY", "clean": True, "export": True, "output_size": "full", "premium": False} + self.av_kwargs = self.kwargs.pop("av_kwargs", AVkwargs) + self.ds = AV.AlphaVantage(**self.av_kwargs) + self.file_path = self.ds.export_path + + if self.ds_name == "yahoo": self.ds = yf - else: - AVkwargs = {"api_key": "YOUR API KEY", "clean": True, "export": True, "output_size": "full", "premium": False} - self.av_kwargs = self.kwargs.pop("av_kwargs", AVkwargs) - self.ds = AV.AlphaVantage(**self.av_kwargs) - self.file_path = self.ds.export_path - def _drop_columns( - self, - df: pd.DataFrame, - cols: list = ["Unnamed: 0", "date", "split_coefficient", "dividend"], - ): + def _drop_columns(self, df: pd.DataFrame, cols: list = None) -> pd.DataFrame: + if cols is None or not isinstance(cols, list): + cols = ["Unnamed: 0", "date", "split_coefficient", "dividend"] + else: cols """Helper methods to drop columns silently.""" df_columns = list(df.columns) if any(_ in df_columns for _ in cols): @@ -123,12 +121,10 @@ class Watchlist(object): keyed by ticker.""" if (self.tickers is not None and isinstance(self.tickers, list) and len(self.tickers)): - self.data = { - ticker: self.load(ticker, **kwargs) for ticker in self.tickers - } + self.data = {ticker: self.load(ticker, **kwargs) for ticker in self.tickers} return self.data - def _plot(self, df, mas:bool = True, constants:bool = True, **kwargs) -> None: + def _plot(self, df, mas:bool = True, constants:bool = False, **kwargs) -> None: if constants: chart_lines = npAppend(npArange(-5, 6, 1), npArange(-100, 110, 10)) @@ -145,22 +141,25 @@ class Watchlist(object): _grid = kwargs.pop("grid", True) _alpha = kwargs.pop("alpha", 1) _last = kwargs.pop("last", 252) - _title = kwargs.pop("title", f"{df.ticker} {_time}") + _title = kwargs.pop("title", f"{df.ticker} {_time} [{self.ds_name}]") col = kwargs.pop("close", "close") - price = df[[col, "SMA_10", "SMA_20", "SMA_50", "SMA_200"]] if mas else df[col] + if mas: + # df.ta.strategy(self.strategy, append=True) + price = df[[col, "SMA_10", "SMA_20", "SMA_50", "SMA_200"]] + else: + price = df[col] - price.tail(_last).plot(figsize=_figsize, color=_colors, linewidth=2, title=_title, grid=_grid, alpha=_alpha) + if _kind is None: + price.tail(_last).plot(figsize=_figsize, color=_colors, linewidth=2, title=_title, grid=_grid, alpha=_alpha) + else: + print(f"[X] Plot kind not implemented") + return - def load( - self, - ticker: str = None, - tf: str = None, - index: str = "date", - drop: list = [], - plot: bool = False, - **kwargs + def load(self, + ticker: str = None, tf: str = None, index: str = "date", + drop: list = [], plot: bool = False, **kwargs ) -> pd.DataFrame: """Loads or Downloads (if a local csv does not exist) the data from the Data Source. When successful, it returns a Data Frame for the requested @@ -179,22 +178,28 @@ class Watchlist(object): # Load local or from Data Source if current_file.exists(): - df = pd.read_csv(current_file, index_col=index) - if not df.ta.datetime_ordered: - df = df.set_index(pd.DatetimeIndex(df.index)) - print(f"[i] Loaded['{tf}']: {filename_}") + file_loaded = f"[i] Loaded {ticker}[{tf}]: {filename_}" + # if self.ds_name == "av": + if self.ds_name in ["av", "yahoo"]: + df = pd.read_csv(current_file, index_col=0) + if not df.ta.datetime_ordered: + df = df.set_index(pd.DatetimeIndex(df.index)) + print(file_loaded) + else: + print(f"[X] {filename_} not found in {Path(self.file_path)}") + return else: - print(f"[+] Downloading['{tf}']: {ticker}") - if isinstance(self.ds, AV.AlphaVantage): + print(f"[+] Downloading[{self.ds_name}]: {ticker}[{tf}]") + if self.ds_name == "av": df = self.ds.data(ticker, tf) if not df.ta.datetime_ordered: df = df.set_index(pd.DatetimeIndex(df[index])) - elif isinstance(self.ds, yfinance): - print("[!] In Development") + if self.ds_name == "yahoo": yf_data = self.ds.Ticker(ticker) df = yf_data.history(period="max") - print(yf_data.info) - print(df) + to_save = f"{self.file_path}/{ticker}_{tf}.csv" + print(f"[+] Saving: {to_save}") + df.to_csv(to_save) # Remove select columns df = self._drop_columns(df, drop) @@ -207,7 +212,6 @@ class Watchlist(object): df.tf = tf if plot: self._plot(df, **kwargs) - return df @property @@ -273,7 +277,7 @@ class Watchlist(object): return self._tickers @tickers.setter - def tickers(self, value: (list, str)) -> None: + def tickers(self, value: Tuple[list, str]) -> None: if value is None: print(f"[X] {value} is not a value in Watchlist ticker.") return @@ -300,7 +304,7 @@ class Watchlist(object): pd.DataFrame().ta.indicators(*args, **kwargs) def __repr__(self) -> str: - s = f"Watch(name='{self.name}', tickers[{len(self.tickers)}]='{', '.join(self.tickers)}', tf='{self.tf}', strategy[{self.strategy.total_ta()}]='{self.strategy.name}'" + s = f"Watch(name='{self.name}', ds_name='{self.ds_name}', tickers[{len(self.tickers)}]='{', '.join(self.tickers)}', tf='{self.tf}', strategy[{self.strategy.total_ta()}]='{self.strategy.name}'" if self.data is not None: s += f", data[{len(self.data.keys())}])" return s diff --git a/pandas_ta/__init__.py b/pandas_ta/__init__.py index bfb07df..7972ef3 100644 --- a/pandas_ta/__init__.py +++ b/pandas_ta/__init__.py @@ -25,9 +25,10 @@ Imports = { "scipy": find_spec("scipy") is not None, "sklearn": find_spec("sklearn") is not None, "statsmodels": find_spec("statsmodels") is not None, + "stochastic": find_spec("stochastic") is not None, "matplotlib": find_spec("matplotlib") is not None, "mplfinance": find_spec("mplfinance") is not None, - "alphaVantage-api ": find_spec("alphaVantageAPI") is not None, + "alphaVantage-api": find_spec("alphaVantageAPI") is not None, "yfinance": find_spec("yfinance") is not None, "talib": find_spec("talib") is not None, } @@ -39,17 +40,19 @@ Category = { "candles": [ "cdl_doji", "cdl_inside", "ha" ], + # Cycles + "cycles": ["ebsw"], # Momentum "momentum": [ "ao", "apo", "bias", "bop", "brar", "cci", "cfo", "cg", "cmo", "coppock", "er", "eri", "fisher", "inertia", "kdj", "kst", "macd", "mom", "pgo", "ppo", "psl", "pvo", "qqe", "roc", "rsi", "rsx", "rvgi", - "slope", "smi", "squeeze", "stoch", "stochrsi", "trix", "tsi", "uo", + "slope", "smi", "squeeze", "stoch", "stochrsi", "td_seq", "trix", "tsi", "uo", "willr" ], # Overlap "overlap": [ - "dema", "ema", "fwma", "hilo", "hl2", "hlc3", "hma", "ichimoku", + "alma", "dema", "ema", "fwma", "hilo", "hl2", "hlc3", "hma", "ichimoku", "kama", "linreg", "mcgd", "midpoint", "midprice", "ohlc4", "pwma", "rma", "sinwma", "sma", "ssf", "supertrend", "swma", "t3", "tema", "trima", "vidya", "vwap", "vwma", "wcp", "wma", "zlma" @@ -69,7 +72,7 @@ Category = { ], # Volatility "volatility": [ - "aberration", "accbands", "atr", "bbands", "donchian", "kc", "massi", + "aberration", "accbands", "atr", "bbands", "donchian", "hwc", "kc", "massi", "natr", "pdist", "rvi", "thermo", "true_range", "ui" ], diff --git a/pandas_ta/candles/cdl_doji.py b/pandas_ta/candles/cdl_doji.py index 37dabc8..591d92d 100644 --- a/pandas_ta/candles/cdl_doji.py +++ b/pandas_ta/candles/cdl_doji.py @@ -1,22 +1,24 @@ # -*- coding: utf-8 -*- from pandas_ta.overlap import sma from pandas_ta.utils import get_offset, high_low_range, is_percent -from pandas_ta.utils import non_zero_range, real_body, verify_series +from pandas_ta.utils import real_body, verify_series -def cdl_doji( open_, high, low, close, length=None, factor=None, scalar=None, asint=True, offset=None, **kwargs): +def cdl_doji(open_, high, low, close, length=None, factor=None, scalar=None, asint=True, offset=None, **kwargs): """Candle Type: Doji""" # Validate Arguments - open_ = verify_series(open_) - high = verify_series(high) - low = verify_series(low) - close = verify_series(close) length = int(length) if length and length > 0 else 10 factor = float(factor) if is_percent(factor) else 10 scalar = float(scalar) if scalar else 100 + open_ = verify_series(open_, length) + high = verify_series(high, length) + low = verify_series(low, length) + close = verify_series(close, length) offset = get_offset(offset) naive = kwargs.pop("naive", False) + if open_ is None or high is None or low is None or close is None: return + # Calculate Result body = real_body(open_, close).abs() hl_range = high_low_range(high, low).abs() @@ -77,7 +79,8 @@ Args: Kwargs: naive (bool, optional): If True, prefills potential Doji less than - the length if less than a percentage of it's high-low range. Default: False + the length if less than a percentage of it's high-low range. + Default: False fillna (value, optional): pd.DataFrame.fillna(value) fill_method (value, optional): Type of fill method diff --git a/pandas_ta/candles/cdl_inside.py b/pandas_ta/candles/cdl_inside.py index e3d767d..8c3fde6 100644 --- a/pandas_ta/candles/cdl_inside.py +++ b/pandas_ta/candles/cdl_inside.py @@ -1,7 +1,6 @@ # -*- coding: utf-8 -*- -from pandas import DataFrame, set_option -from pandas_ta.utils import candle_color, get_drift, get_offset -from pandas_ta.utils import non_zero_range, real_body, verify_series +from pandas_ta.utils import candle_color, get_offset +from pandas_ta.utils import verify_series def cdl_inside(open_, high, low, close, asbool=False, offset=None, **kwargs): diff --git a/pandas_ta/candles/ha.py b/pandas_ta/candles/ha.py index 383e9ea..1e0f53f 100644 --- a/pandas_ta/candles/ha.py +++ b/pandas_ta/candles/ha.py @@ -1,5 +1,4 @@ # -*- coding: utf-8 -*- -import numpy as np from pandas import DataFrame from pandas_ta.utils import get_offset, verify_series diff --git a/pandas_ta/core.py b/pandas_ta/core.py index fe82a07..2ca01f5 100644 --- a/pandas_ta/core.py +++ b/pandas_ta/core.py @@ -1,16 +1,17 @@ # -*- coding: utf-8 -*- from dataclasses import dataclass, field -from datetime import datetime from multiprocessing import cpu_count, Pool from time import perf_counter from typing import List, Tuple import pandas as pd -from numpy import ndarray as npndarray +from numpy import log10 as npLog10 +from numpy import ndarray as npNdarray from pandas.core.base import PandasObject -from pandas_ta import version, Category +from pandas_ta import Category, version from pandas_ta.candles import * +from pandas_ta.cycles import * from pandas_ta.momentum import * from pandas_ta.overlap import * from pandas_ta.performance import * @@ -21,6 +22,8 @@ from pandas_ta.volume import * from pandas_ta.utils import * +df = pd.DataFrame() + # Strategy DataClass @dataclass class Strategy: @@ -48,8 +51,8 @@ class Strategy: ta: List = field(default_factory=list) # Required. # Helpful. More descriptive version or notes or w/e. description: str = "TA Description" - # Optional. May change type later to datetime - created: str = datetime.now().strftime("%m/%d/%Y, %H:%M:%S") + # Optional. Gets Exchange Time and Local Time execution time + created: str = get_time(to_string=True) def __post_init__(self): has_name = True @@ -60,9 +63,7 @@ class Strategy: ta_is_list = isinstance(self.ta, list) if self.name is None or not name_is_str: - required_args.append( - ' - name. Must be a string. Example: "My TA". Note: "all" is reserved.' - ) + required_args.append(' - name. Must be a string. Example: "My TA". Note: "all" is reserved.') has_name != has_name if self.ta is None: @@ -71,8 +72,7 @@ class Strategy: # Check that all elements of the list are dicts. # Does not check if the dicts values are valid indicator kwargs # User must check indicator documentation for all indicators args. - is_ta = all( - [isinstance(_, dict) and len(_.keys()) > 0 for _ in self.ta]) + is_ta = all([isinstance(_, dict) and len(_.keys()) > 0 for _ in self.ta]) else: s = " - ta. Format is a list of dicts. Example: [{'kind': 'sma', 'length': 10}]" s += "\n Check the indicator for the correct arguments if you receive this error." @@ -119,9 +119,7 @@ class BasePandasObject(PandasObject): """ def __init__(self, df, **kwargs): - if df.empty: - return - + if df.empty: return if len(df.columns) > 0: common_names = { "Date": "date", @@ -134,6 +132,8 @@ class BasePandasObject(PandasObject): "Close": "close", "Adj Close": "adj_close", "Volume": "volume", + "Dividends": "dividends", + "Stock Splits": "split", } # Preemptively drop the rows that are all NaNs # Might need to be moved to AnalysisIndicators.__call__() to be @@ -158,17 +158,23 @@ class BasePandasObject(PandasObject): # Pandas TA - DataFrame Analysis Indicators @pd.api.extensions.register_dataframe_accessor("ta") class AnalysisIndicators(BasePandasObject): - """AnalysisIndicators is a class that extends the Pandas DataFrame via - Pandas @pd.api.extensions.register_dataframe_accessor('name') decorator. + """ + This Pandas Extension is named 'ta' for Technical Analysis. In other words, + it is a Numerical Time Series Feature Generator where the Time Series data + is biased towards Financial Market data; typical data includes columns + named :"open", "high", "low", "close", "volume". - This Pandas Extension is named 'ta' for Technical Analysis that allows us - to apply technical indicators by extension. Even though 'ta' is a - Pandas DataFrame Extension, you can still call the Indicators - individually. Use help() if needed. + This TA Library hopefully allows you to apply familiar and unique Technical + Analysis Indicators easily with the DataFrame Extension named 'ta'. Even + though 'ta' is a Pandas DataFrame Extension, you can still call Technical + Analysis indicators individually if you are more comfortable with that + approach or it allows you to easily and automatically apply the indicators + with the strategy method. See: help(ta.strategy). - By default the 'ta' extension uses lower case column names: open, high, - low, close, and volume. You can override the defaults by providing the - it's replacement name when calling the indicator. For example, to call the indicator hl2(). + By default, the 'ta' extension uses lower case column names: open, high, + low, close, and volume. You can override the defaults by providing the it's + replacement name when calling the indicator. For example, to call the + indicator hl2(). With 'default' columns: open, high, low, close, and volume. >>> df.ta.hl2() @@ -217,12 +223,15 @@ class AnalysisIndicators(BasePandasObject): >>> help(df.ta.apo) 4. Ways of calling an indicator. - 4a. Calling just the MACD indicator without "ta" DataFrame extension. + 4a. Standard: Calling just the APO indicator without "ta" DataFrame extension. >>> ta.apo(df["close"]) - 4b. Calling just the MACD indicator with "ta" DataFrame extension. + 4b. DataFrame Extension: Calling just the APO indicator with "ta" DataFrame extension. >>> df.ta.apo() - 4c. Calling using kind. + 4c. DataFrame Extension (kind): Calling APO using 'kind' >>> df.ta(kind="apo") + 4d. Strategy: + >>> df.ta.strategy("All") # Default + >>> df.ta.strategy(ta.Strategy("My Strat", ta=[{"kind": "apo"}])) # Custom 5. Working with kwargs 5a. Append the result to the working df. @@ -234,15 +243,27 @@ class AnalysisIndicators(BasePandasObject): _adjusted = None _cores = cpu_count() - _mp = False + _df = DataFrame() + _exchange = "NYSE" + _time_range = "years" + _last_run = get_time(_exchange, to_string=True) + + # def __init__(self, pandas_obj): + # # self._validate(pandas_obj) + # self._df = pandas_obj + # self._last_run = get_time(self._exchange, to_string=True) + + # @staticmethod + # def _validate(df: Tuple[pd.DataFrame, pd.Series]): + # if isinstance(df, pd.Series) or isinstance(df, pd.DataFrame): + # raise AttributeError("[X] Must be either a Pandas Series or DataFrame.") # DataFrame Behavioral Methods def __call__( self, kind: str = None, - alias: str = None, timed: bool = False, - verbose: bool = False, **kwargs + timed: bool = False, version: bool = False, **kwargs ): - if verbose: print(f"Pandas TA - Technical Analysis Indicators - v{self.version}") + if version: print(f"Pandas TA - Technical Analysis Indicators - v{self.version}") try: if isinstance(kind, str): kind = kind.lower() @@ -253,15 +274,11 @@ class AnalysisIndicators(BasePandasObject): # Run the indicator result = fn(**kwargs) # = getattr(self, kind)(**kwargs) + self._last_run = get_time(self.exchange, to_string=True) # Save when it completed it's run if timed: result.timed = final_time(stime) - alias_str = alias + ":" if alias is not None else "" - print(f"[+] {kind}:{alias_str} {result.timed}") - - # Add an alias if passed - if alias: - result.alias = f"{alias}" + print(f"[+] {kind}: {result.timed}") return result else: @@ -294,22 +311,25 @@ class AnalysisIndicators(BasePandasObject): """property: df.ta.cores = integer""" cpus = cpu_count() if value is not None and isinstance(value, int): - self._cores = int(value) if 0 < value <= cpus else cpus + self._cores = int(value) if 0 <= value <= cpus else cpus else: self._cores = cpus @property - def mp(self) -> bool: - """property: df.ta.mp""" - return self._mp + def exchange(self) -> str: + """Returns the current Exchange. Default: "NYSE".""" + return self._exchange - @mp.setter - def mp(self, value: bool) -> None: - """property: df.ta.mp = False (Default)""" - if value is not None and isinstance(value, bool): - self._mp = value - else: - self._mp = False + @exchange.setter + def exchange(self, value: str) -> None: + """property: df.ta.exchange = "LSE" """ + if value is not None and isinstance(value, str) and value in EXCHANGE_TZ.keys(): + self._exchange = value + + @property + def last_run(self) -> str: + """Returns the time when the DataFrame was last run.""" + return self._last_run # Public Get DataFrame Properties @property @@ -330,6 +350,24 @@ class AnalysisIndicators(BasePandasObject): """Reverses the DataFrame. Simply: df.iloc[::-1]""" return self._df.iloc[::-1] + @property + def time_range(self) -> float: + """Returns the time ranges of the DataFrame as a float. Default is in "years". help(ta.toal_time)""" + return total_time(self._df, self._time_range) + + @time_range.setter + def time_range(self, value: str) -> None: + """property: df.ta.time_range = "years" (Default)""" + if value is not None and isinstance(value, str): + self._time_range = value + else: + self._time_range = "years" + + @property + def to_utc(self) -> None: + """Sets the DataFrame index to UTC format""" + self._df = to_utc(self._df) + @property def version(self) -> str: """Returns the version.""" @@ -352,33 +390,23 @@ class AnalysisIndicators(BasePandasObject): if isinstance(result, pd.Series): result.name = prefix + result.name + suffix else: - result.columns = [ - prefix + column + suffix for column in result.columns - ] + result.columns = [prefix + column + suffix for column in result.columns] def _append(self, result=None, **kwargs) -> None: """Appends a Pandas Series or DataFrame columns to self._df.""" if "append" in kwargs and kwargs["append"]: df = self._df - na_columns = self._check_na_columns() - if df is None or result is None: - return - elif len(na_columns): - print(f"[X] {result.name} column(s) values are all na: {', '.join(na_columns)}") - return + if df is None or result is None: return else: if isinstance(result, pd.DataFrame): - # If specified in kwargs, rename the columns. If not, use - # the default names. - if "col_names" in kwargs and isinstance( - kwargs["col_names"], tuple): + # If specified in kwargs, rename the columns. + # If not, use the default names. + if "col_names" in kwargs and isinstance(kwargs["col_names"], tuple): if len(kwargs["col_names"]) >= len(result.columns): for col, ind_name in zip(result.columns, kwargs["col_names"]): df[ind_name] = result.loc[:, col] else: - print( - f"Not enough col_names were specified : got {len(kwargs['col_names'])}, expected {len(result.columns)}." - ) + print(f"Not enough col_names were specified : got {len(kwargs['col_names'])}, expected {len(result.columns)}.") return else: for i, column in enumerate(result.columns): @@ -386,7 +414,8 @@ class AnalysisIndicators(BasePandasObject): else: ind_name = ( kwargs["col_names"][0] if "col_names" in kwargs and - isinstance(kwargs["col_names"], tuple) else result.name) + isinstance(kwargs["col_names"], tuple) else result.name + ) df[ind_name] = result def _check_na_columns(self, stdout: bool = True): @@ -396,8 +425,7 @@ class AnalysisIndicators(BasePandasObject): def _get_column(self, series): """Attempts to get the correct series or 'column' and return it.""" df = self._df - if df is None: - return + if df is None: return # Explicitly passing a pd.Series to override default. if isinstance(series, pd.Series): @@ -438,8 +466,10 @@ class AnalysisIndicators(BasePandasObject): * Applies prefixes and/or suffixes * Appends the result to main DataFrame """ + verbose = kwargs.pop("verbose", False) if not isinstance(result, (pd.Series, pd.DataFrame)): - print(f"[X] Oops! The result was not a Series or DataFrame.") + if verbose: + print(f"[X] Oops! The result was not a Series or DataFrame.") return self._df else: # Append only specific columns to the dataframe (via @@ -491,7 +521,7 @@ class AnalysisIndicators(BasePandasObject): Remove constant '1' to the DataFrame >>> df.ta.constants(False, [1]) - Adding the constants for the charts + Adding constants for charting >>> import numpy as np >>> chart_lines = np.append(np.arange(-4, 5, 1), np.arange(-100, 110, 10)) >>> df.ta.constants(True, chart_lines) @@ -508,7 +538,7 @@ class AnalysisIndicators(BasePandasObject): Returns nothing to the user. Either adds or removes constant ranges from the working DataFrame. """ - if isinstance(values, npndarray) or isinstance(values, list): + if isinstance(values, npNdarray) or isinstance(values, list): if append: for x in values: self._df[f"{x}"] = x @@ -520,12 +550,11 @@ class AnalysisIndicators(BasePandasObject): def indicators(self, **kwargs): """List of Indicators - Args: - kwargs: - as_list (bool, optional): Default: False. When True, it - returns a list of the indicators. - exclude (list, optional): Default: None. The passed in list - will be excluded from the indicators list. + kwargs: + as_list (bool, optional): When True, it returns a list of the + indicators. Default: False. + exclude (list, optional): The passed in list will be excluded + from the indicators list. Default: None. Returns: Prints the list of indicators. If as_list=True, then a list. @@ -539,8 +568,12 @@ class AnalysisIndicators(BasePandasObject): "categories", "cores", "datetime_ordered", - "mp", + "exchange", + "last_run", "reverse", + "ticker", + "time_range", + "to_utc", "version", ] @@ -574,20 +607,31 @@ class AnalysisIndicators(BasePandasObject): """Strategy Method An experimental method that by default runs all applicable indicators. - Future implementations will allow more specific indicator generation through - a json config file. + Future implementations will allow more specific indicator generation + with possibly as json, yaml config file or an sqlite3 table. - Args: - name (str, optional): Default: "all" - exclude (list, optional): Default: []. List of indicator names to exclude. - kwargs: - (optional) Default: {}. Any indicator argument you want to modify. - For example, length=20 or offset=-1 or high=df["high"] ... + Kwargs: + chunksize (bool): Adjust the chunksize for the Multiprocessing Pool. + Default: Number of cores of the OS + exclude (list): List of indicator names to exclude. Some are + excluded by default for various reasons; they require additional + sources, performance (td_seq), not a ohlcv chart (vp) etc. + name (str): Select all indicators or indicators by + Category such as: "candles", "cycles", "momentum", "overlap", + "performance", "statistics", "trend", "volatility", "volume", or + "all". Default: "all" + ordered (bool): Whether to run "all" in order. Default: True + timed (bool): Show the process time of the strategy(). + Default: False + verbose (bool): Provide some additional insight on the progress of + the strategy() execution. Default: False """ # cpus = cpu_count() # Ensure indicators are appended to the DataFrame kwargs["append"] = True + all_ordered = kwargs.pop("ordered", True) + mp_chunksize = kwargs.pop("chunksize", self.cores) # Initialize initial_column_count = len(self._df.columns) @@ -598,9 +642,11 @@ class AnalysisIndicators(BasePandasObject): "below_value", "cross", "cross_value", + # "data", # reserved "long_run", "short_run", "trend_return", + "td_seq", # Performance exclusion "vp", ] @@ -626,6 +672,15 @@ class AnalysisIndicators(BasePandasObject): print(f"[X] Not an available strategy.") return None + # Remove Custom indicators with "length" keyword when larger than the DataFrame + # Possible to have other indicator main window lengths to be included + removal = [] + for kwds in ta: + _ = False + if "length" in kwds and kwds["length"] > self._df.shape[0]: _ = True + if _: removal.append(kwds) + if len(removal) > 0: [ta.remove(x) for x in removal] + verbose = kwargs.pop("verbose", False) if verbose: print(f"[+] Strategy: {name}\n[i] Indicator arguments: {kwargs}") @@ -635,62 +690,145 @@ class AnalysisIndicators(BasePandasObject): timed = kwargs.pop("timed", False) results = [] - pool = Pool(self.cores) + use_multiprocessing = True if self.cores > 0 else False + has_col_names = False + if timed: stime = perf_counter() - if mode["custom"]: + + if use_multiprocessing and mode["custom"]: # Determine if the Custom Model has 'col_names' parameter has_col_names = (True if len([ True for x in ta if "col_names" in x and isinstance(x["col_names"], tuple) ]) else False) - # Create a list of all the custom indicators into a list - custom_ta = [( - ind["kind"], - ind["params"] if "params" in ind and isinstance(ind["params"], tuple) else (), - {**ind, **kwargs}, - ) for ind in ta] - if has_col_names: - if verbose: + use_multiprocessing = False + + if use_multiprocessing: + _total_ta = len(ta) + pool = Pool(self.cores) + # Some magic to optimize chunksize for speed based on total ta indicators + _chunksize = mp_chunksize - 1 if mp_chunksize > _total_ta else int(npLog10(_total_ta)) + 1 + if verbose: + print(f"[i] Multiprocessing {_total_ta} indicators with {_chunksize} chunks and {self.cores}/{cpu_count()} cpus.") + + results = None + if mode["custom"]: + # Create a list of all the custom indicators into a list + custom_ta = [( + ind["kind"], + ind["params"] if "params" in ind and isinstance(ind["params"], tuple) else (), + {**ind, **kwargs}, + ) for ind in ta] + # Custom multiprocessing pool. Must be ordered for Chained Strategies + # May fix this to cpus if Chaining/Composition if it remains + results = pool.imap(self._mp_worker, custom_ta, _chunksize) + else: + default_ta = [(ind, tuple(), kwargs) for ind in ta] + # All and Categorical multiprocessing pool. + if all_ordered: + results = pool.imap(self._mp_worker, default_ta, _chunksize) # Order over Speed + else: + results = pool.imap_unordered(self._mp_worker, default_ta, _chunksize) # Speed over Order + if results is None: + print(f"[X] ta.strategy('{name}') has no results.") + return + + pool.close() + pool.join() + self._last_run = get_time(self.exchange, to_string=True) + + else: + # Without multiprocessing: + if verbose: + if has_col_names: print(f"[i] No mulitproccessing support for 'col_names' option.") - # Without multiprocessing: + else: + print(f"[i] No mulitproccessing (cores = 0).") + + if mode["custom"]: for ind in ta: params = ind["params"] if "params" in ind and isinstance(ind["params"], tuple) else tuple() getattr(self, ind["kind"])(*params, **{**ind, **kwargs}) else: - if verbose: - print(f"[i] Multiprocessing: {self.cores} of {cpu_count()} cores.") - - # Custom multiprocessing pool. Must be ordered for Chained Strategies - # May fix this to cpus if Chaining/Composition if it remains - # inconsistent - results = pool.imap(self._mp_worker, custom_ta, self.cores) - - else: - if verbose: - print(f"[i] Multiprocessing: {self.cores} of {cpu_count()} cores.") - default_ta = [(ind, tuple(), kwargs) for ind in ta] - # All and Categorical multiprocessing pool. Speed over Order. - results = pool.imap_unordered(self._mp_worker, default_ta, self.cores) - pool.close() - pool.join() + for ind in ta: + getattr(self, ind)(*tuple(), **kwargs) # Apply prefixes/suffixes and appends indicator results to the # DataFrame [self._post_process(r, **kwargs) for r in results] - if timed: - ftime = final_time(stime) - if verbose: print(f"[i] Total indicators: {len(ta)}") - print( - f"[i] Columns added: {len(self._df.columns) - initial_column_count}" - ) + print(f"[i] Columns added: {len(self._df.columns) - initial_column_count}") + print(f"[i] Last Run: {self._last_run}") if timed: - print(f"[i] Runtime: {ftime}") + print(f"[i] Runtime: {final_time(stime)}") + + def ticker(self, ticker, **kwargs): + """ticker + + This method downloads Historical Data if the package yfinance is installed. + Additionally it can run a ta.Strategy; Builtin or Custom. It returns a + DataFrame if there the DataFrame is not empty, otherwise it exits. For + additional yfinance arguments, use help(ta.yf). + + Historical Data + >>> df = df.ta.ticker("aapl") + More specifically + >>> df = df.ta.ticker("aapl", period="max", interval="1d", kind=None) + + Changing the period of Historical Data + Period is used instead of start/end + >>> df = df.ta.ticker("aapl", period="1y") + + Changing the period and interval of Historical Data + Retrieves the past year in weeks + >>> df = df.ta.ticker("aapl", period="1y", interval="1wk") + Retrieves the past month in hours + >>> df = df.ta.ticker("aapl", period="1mo", interval="1h") + + Show everything + >>> df = df.ta.ticker("aapl", kind="all") + + Args: + ticker (str): Any string for a ticker you would use with yfinance. + Default: "SPY" + Kwargs: + kind (str): Options see above. Default: "history" + ds (str): Data Source to use. Default: "yahoo" + strategy (str | ta.Strategy): Which strategy to apply after + downloading chart history. Default: None + + See help(ta.yf) for additional kwargs + + Returns: + Exits if the DataFrame is empty or None + Otherwise it returns a DataFrame + """ + ds = kwargs.pop("ds", "yahoo") + strategy = kwargs.pop("strategy", None) + + # Fetch the Data + ds = ds.lower() is not None and isinstance(ds, str) + # df = av(ticker, **kwargs) if ds and ds == "av" else yf(ticker, **kwargs) + df = yf(ticker, **kwargs) + + if df is None: return + elif df.empty: + print(f"[X] DataFrame is empty: {df.shape}") + return + else: + if kwargs.pop("lc_input", False): + df.index.name = df.index.name.lower() + df.columns = df.columns.str.lower() + self._df = df + + if strategy is not None: self.strategy(strategy, **kwargs) + return df + # Public DataFrame Methods: Indicators and Utilities # Candles @@ -699,7 +837,6 @@ class AnalysisIndicators(BasePandasObject): high = self._get_column(kwargs.pop("high", "high")) low = self._get_column(kwargs.pop("low", "low")) close = self._get_column(kwargs.pop("close", "close")) - result = cdl_doji(open_=open_, high=high, low=low, close=close, offset=offset, **kwargs) return self._post_process(result, **kwargs) @@ -708,7 +845,6 @@ class AnalysisIndicators(BasePandasObject): high = self._get_column(kwargs.pop("high", "high")) low = self._get_column(kwargs.pop("low", "low")) close = self._get_column(kwargs.pop("close", "close")) - result = cdl_inside(open_=open_, high=high, low=low, close=close, offset=offset, **kwargs) return self._post_process(result, **kwargs) @@ -717,15 +853,19 @@ class AnalysisIndicators(BasePandasObject): high = self._get_column(kwargs.pop("high", "high")) low = self._get_column(kwargs.pop("low", "low")) close = self._get_column(kwargs.pop("close", "close")) - result = ha(open_=open_, high=high, low=low, close=close, offset=offset, **kwargs) return self._post_process(result, **kwargs) + # Cycles + def ebsw(self, close=None, length=None, bars=None, offset=None, **kwargs): + close = self._get_column(kwargs.pop("close", "close")) + result = ebsw(close=close, length=length, bars=bars, offset=offset, **kwargs) + return self._post_process(result, **kwargs) + # Momentum def ao(self, fast=None, slow=None, offset=None, **kwargs): high = self._get_column(kwargs.pop("high", "high")) low = self._get_column(kwargs.pop("low", "low")) - result = ao(high=high, low=low, fast=fast, slow=slow, offset=offset, **kwargs) return self._post_process(result, **kwargs) @@ -744,7 +884,6 @@ class AnalysisIndicators(BasePandasObject): high = self._get_column(kwargs.pop("high", "high")) low = self._get_column(kwargs.pop("low", "low")) close = self._get_column(kwargs.pop("close", "close")) - result = bop(open_=open_, high=high, low=low, close=close, percentage=percentage, offset=offset, **kwargs) return self._post_process(result, **kwargs) @@ -753,7 +892,6 @@ class AnalysisIndicators(BasePandasObject): high = self._get_column(kwargs.pop("high", "high")) low = self._get_column(kwargs.pop("low", "low")) close = self._get_column(kwargs.pop("close", "close")) - result = brar(open_=open_, high=high, low=low, close=close, length=length, scalar=scalar, drift=drift, offset=offset, **kwargs) return self._post_process(result, **kwargs) @@ -761,7 +899,6 @@ class AnalysisIndicators(BasePandasObject): high = self._get_column(kwargs.pop("high", "high")) low = self._get_column(kwargs.pop("low", "low")) close = self._get_column(kwargs.pop("close", "close")) - result = cci(high=high, low=low, close=close, length=length, c=c, offset=offset, **kwargs) return self._post_process(result, **kwargs) @@ -794,14 +931,12 @@ class AnalysisIndicators(BasePandasObject): high = self._get_column(kwargs.pop("high", "high")) low = self._get_column(kwargs.pop("low", "low")) close = self._get_column(kwargs.pop("close", "close")) - result = eri(high=high, low=low, close=close, length=length, offset=offset, **kwargs) return self._post_process(result, **kwargs) def fisher(self, length=None, signal=None, offset=None, **kwargs): high = self._get_column(kwargs.pop("high", "high")) low = self._get_column(kwargs.pop("low", "low")) - result = fisher(high=high, low=low, length=length, signal=signal, offset=offset, **kwargs) return self._post_process(result, **kwargs) @@ -820,7 +955,6 @@ class AnalysisIndicators(BasePandasObject): high = self._get_column(kwargs.pop("high", "high")) low = self._get_column(kwargs.pop("low", "low")) close = self._get_column(kwargs.pop("close", "close")) - result = kdj(high=high, low=low, close=close, length=length, signal=signal, offset=offset, **kwargs) return self._post_process(result, **kwargs) @@ -843,7 +977,6 @@ class AnalysisIndicators(BasePandasObject): high = self._get_column(kwargs.pop("high", "high")) low = self._get_column(kwargs.pop("low", "low")) close = self._get_column(kwargs.pop("close", "close")) - result = pgo(high=high, low=low, close=close, length=length, offset=offset, **kwargs) return self._post_process(result, **kwargs) @@ -890,7 +1023,6 @@ class AnalysisIndicators(BasePandasObject): high = self._get_column(kwargs.pop("high", "high")) low = self._get_column(kwargs.pop("low", "low")) close = self._get_column(kwargs.pop("close", "close")) - result = rvgi(open_=open_, high=high, low=low, close=close, length=length, swma_length=swma_length, offset=offset, **kwargs) return self._post_process(result, **kwargs) @@ -908,7 +1040,6 @@ class AnalysisIndicators(BasePandasObject): high = self._get_column(kwargs.pop("high", "high")) low = self._get_column(kwargs.pop("low", "low")) close = self._get_column(kwargs.pop("close", "close")) - result = squeeze(high=high, low=low, close=close, bb_length=bb_length, bb_std=bb_std, kc_length=kc_length, kc_scalar=kc_scalar, mom_length=mom_length, mom_smooth=mom_smooth, use_tr=use_tr, offset=offset, **kwargs) return self._post_process(result, **kwargs) @@ -916,7 +1047,6 @@ class AnalysisIndicators(BasePandasObject): high = self._get_column(kwargs.pop("high", "high")) low = self._get_column(kwargs.pop("low", "low")) close = self._get_column(kwargs.pop("close", "close")) - result = stoch(high=high, low=low, close=close, fast_k=fast_k, slow_k=slow_k, slow_d=slow_d, offset=offset, **kwargs) return self._post_process(result, **kwargs) @@ -924,10 +1054,14 @@ class AnalysisIndicators(BasePandasObject): high = self._get_column(kwargs.pop("high", "high")) low = self._get_column(kwargs.pop("low", "low")) close = self._get_column(kwargs.pop("close", "close")) - result = stochrsi(high=high, low=low, close=close, length=length, rsi_length=rsi_length, k=k, d=d, offset=offset, **kwargs) return self._post_process(result, **kwargs) + def td_seq(self, asint=None, offset=None, show_all=None, **kwargs): + close = self._get_column(kwargs.pop("close", "close")) + result = td_seq(close=close, asint=asint, offset=offset, show_all=show_all, **kwargs) + return self._post_process(result, **kwargs) + def trix(self, length=None, signal=None, scalar=None, drift=None, offset=None, **kwargs): close = self._get_column(kwargs.pop("close", "close")) result = trix(close=close, length=length, signal=signal, scalar=scalar, drift=drift, offset=offset, **kwargs) @@ -942,7 +1076,6 @@ class AnalysisIndicators(BasePandasObject): high = self._get_column(kwargs.pop("high", "high")) low = self._get_column(kwargs.pop("low", "low")) close = self._get_column(kwargs.pop("close", "close")) - result = uo(high=high, low=low, close=close, fast=fast, medium=medium, slow=slow, fast_w=fast_w, medium_w=medium_w, slow_w=slow_w, drift=drift, offset=offset, **kwargs) return self._post_process(result, **kwargs) @@ -950,11 +1083,15 @@ class AnalysisIndicators(BasePandasObject): high = self._get_column(kwargs.pop("high", "high")) low = self._get_column(kwargs.pop("low", "low")) close = self._get_column(kwargs.pop("close", "close")) - result = willr(high=high, low=low, close=close, length=length, percentage=percentage, offset=offset, **kwargs) return self._post_process(result, **kwargs) # Overlap + def alma(self, length=None, sigma=None, distribution_offset=None, offset=None, **kwargs): + close = self._get_column(kwargs.pop("close", "close")) + result = alma(close=close, length=length, sigma=sigma, distribution_offset=distribution_offset, offset=offset, **kwargs) + return self._post_process(result, **kwargs) + def dema(self, length=None, offset=None, **kwargs): close = self._get_column(kwargs.pop("close", "close")) result = dema(close=close, length=length, offset=offset, **kwargs) @@ -974,14 +1111,12 @@ class AnalysisIndicators(BasePandasObject): high = self._get_column(kwargs.pop("high", "high")) low = self._get_column(kwargs.pop("low", "low")) close = self._get_column(kwargs.pop("close", "close")) - result = hilo(high=high, low=low, close=close, high_length=high_length, low_length=low_length, mamode=mamode, offset=offset, **kwargs) return self._post_process(result, **kwargs) def hl2(self, offset=None, **kwargs): high = self._get_column(kwargs.pop("high", "high")) low = self._get_column(kwargs.pop("low", "low")) - result = hl2(high=high, low=low, offset=offset, **kwargs) return self._post_process(result, **kwargs) @@ -989,7 +1124,6 @@ class AnalysisIndicators(BasePandasObject): high = self._get_column(kwargs.pop("high", "high")) low = self._get_column(kwargs.pop("low", "low")) close = self._get_column(kwargs.pop("close", "close")) - result = hlc3(high=high, low=low, close=close, offset=offset, **kwargs) return self._post_process(result, **kwargs) @@ -998,6 +1132,11 @@ class AnalysisIndicators(BasePandasObject): result = hma(close=close, length=length, offset=offset, **kwargs) return self._post_process(result, **kwargs) + def hwma(self, na=None, nb=None, nc=None, offset=None, **kwargs): + close = self._get_column(kwargs.pop("close", "close")) + result = hwma(close=close, na=na, nb=nb, nc=nc, offset=offset, **kwargs) + return self._post_process(result, **kwargs) + def kama(self, length=None, fast=None, slow=None, offset=None, **kwargs): close = self._get_column(kwargs.pop("close", "close")) result = kama(close=close, length=length, fast=fast, slow=slow, offset=offset, **kwargs) @@ -1007,7 +1146,6 @@ class AnalysisIndicators(BasePandasObject): high = self._get_column(kwargs.pop("high", "high")) low = self._get_column(kwargs.pop("low", "low")) close = self._get_column(kwargs.pop("close", "close")) - result, span = ichimoku(high=high, low=low, close=close, tenkan=tenkan, kijun=kijun, senkou=senkou, offset=offset, **kwargs) self._add_prefix_suffix(result, **kwargs) self._add_prefix_suffix(span, **kwargs) @@ -1033,7 +1171,6 @@ class AnalysisIndicators(BasePandasObject): def midprice(self, length=None, offset=None, **kwargs): high = self._get_column(kwargs.pop("high", "high")) low = self._get_column(kwargs.pop("low", "low")) - result = midprice(high=high, low=low, length=length, offset=offset, **kwargs) return self._post_process(result, **kwargs) @@ -1074,7 +1211,6 @@ class AnalysisIndicators(BasePandasObject): high = self._get_column(kwargs.pop("high", "high")) low = self._get_column(kwargs.pop("low", "low")) close = self._get_column(kwargs.pop("close", "close")) - result = supertrend(high=high, low=low, close=close, length=length, multiplier=multiplier, offset=offset, **kwargs) return self._post_process(result, **kwargs) @@ -1118,7 +1254,6 @@ class AnalysisIndicators(BasePandasObject): def vwma(self, volume=None, length=None, offset=None, **kwargs): close = self._get_column(kwargs.pop("close", "close")) volume = self._get_column(kwargs.pop("volume", "volume")) - result = vwma(close=close, volume=close, length=length, offset=offset, **kwargs) return self._post_process(result, **kwargs) @@ -1126,7 +1261,6 @@ class AnalysisIndicators(BasePandasObject): high = self._get_column(kwargs.pop("high", "high")) low = self._get_column(kwargs.pop("low", "low")) close = self._get_column(kwargs.pop("close", "close")) - result = wcp(high=high, low=low, close=close, offset=offset, **kwargs) return self._post_process(result, **kwargs) @@ -1210,7 +1344,6 @@ class AnalysisIndicators(BasePandasObject): high = self._get_column(kwargs.pop("high", "high")) low = self._get_column(kwargs.pop("low", "low")) close = self._get_column(kwargs.pop("close", "close")) - result = adx(high=high, low=low, close=close, length=length, scalar=scalar, drift=drift, offset=offset, **kwargs) return self._post_process(result, **kwargs) @@ -1222,7 +1355,6 @@ class AnalysisIndicators(BasePandasObject): def aroon(self, length=None, scalar=None, offset=None, **kwargs): high = self._get_column(kwargs.pop("high", "high")) low = self._get_column(kwargs.pop("low", "low")) - result = aroon(high=high, low=low, length=length, scalar=scalar, offset=offset, **kwargs) return self._post_process(result, **kwargs) @@ -1230,7 +1362,6 @@ class AnalysisIndicators(BasePandasObject): high = self._get_column(kwargs.pop("high", "high")) low = self._get_column(kwargs.pop("low", "low")) close = self._get_column(kwargs.pop("close", "close")) - result = chop(high=high, low=low, close=close, length=length, atr_length=atr_length, scalar=scalar, drift=drift, offset=offset, **kwargs) return self._post_process(result, **kwargs) @@ -1238,7 +1369,6 @@ class AnalysisIndicators(BasePandasObject): high = self._get_column(kwargs.pop("high", "high")) low = self._get_column(kwargs.pop("low", "low")) close = self._get_column(kwargs.pop("close", "close")) - result = cksp(high=high, low=low, close=close, p=p, x=x, q=q, offset=offset, **kwargs) return self._post_process(result, **kwargs) @@ -1279,7 +1409,6 @@ class AnalysisIndicators(BasePandasObject): def qstick(self, length=None, offset=None, **kwargs): open_ = self._get_column(kwargs.pop("open", "open")) close = self._get_column(kwargs.pop("close", "close")) - result = qstick(open_=open_, close=close, length=length, offset=offset, **kwargs) return self._post_process(result, **kwargs) @@ -1294,7 +1423,6 @@ class AnalysisIndicators(BasePandasObject): high = self._get_column(kwargs.pop("high", "high")) low = self._get_column(kwargs.pop("low", "low")) close = self._get_column(kwargs.pop("close", "close")) - result = supertrend(high=high, low=low, close=close, period=period, multiplier=multiplier, mamode=mamode, drift=drift, offset=offset, **kwargs) return self._post_process(result, **kwargs) @@ -1302,7 +1430,6 @@ class AnalysisIndicators(BasePandasObject): high = self._get_column(kwargs.pop("high", "high")) low = self._get_column(kwargs.pop("low", "low")) close = self._get_column(kwargs.pop("close", "close")) - result = ttm_trend(high=high, low=low, close=close, length=length, offset=offset, **kwargs) return self._post_process(result, **kwargs) @@ -1310,7 +1437,6 @@ class AnalysisIndicators(BasePandasObject): high = self._get_column(kwargs.pop("high", "high")) low = self._get_column(kwargs.pop("low", "low")) close = self._get_column(kwargs.pop("close", "close")) - result = vortex(high=high, low=low, close=close, drift=drift, offset=offset, **kwargs) return self._post_process(result, **kwargs) @@ -1319,49 +1445,33 @@ class AnalysisIndicators(BasePandasObject): a = self._get_column(kwargs.pop("close", "a")) b = self._get_column(kwargs.pop("close", "b")) result = above(series_a=a, series_b=b, asint=asint, offset=offset, **kwargs) - - # self._add_prefix_suffix(result, **kwargs) - # self._append(result, **kwargs) return self._post_process(result, **kwargs) def above_value(self, value=None, asint=True, offset=None, **kwargs): a = self._get_column(kwargs.pop("close", "a")) result = above_value(series_a=a, value=value, asint=asint, offset=offset, **kwargs) - - # self._add_prefix_suffix(result, **kwargs) - # self._append(result, **kwargs) return self._post_process(result, **kwargs) def below(self, asint=True, offset=None, **kwargs): a = self._get_column(kwargs.pop("close", "a")) b = self._get_column(kwargs.pop("close", "b")) result = below(series_a=a, series_b=b, asint=asint, offset=offset, **kwargs) - # self._add_prefix_suffix(result, **kwargs) - # self._append(result, **kwargs) return self._post_process(result, **kwargs) def below_value(self, value=None, asint=True, offset=None, **kwargs): a = self._get_column(kwargs.pop("close", "a")) result = below_value(series_a=a, value=value, asint=asint, offset=offset, **kwargs) - - # self._add_prefix_suffix(result, **kwargs) - # self._append(result, **kwargs) return self._post_process(result, **kwargs) def cross(self, above=True, asint=True, offset=None, **kwargs): a = self._get_column(kwargs.pop("close", "a")) b = self._get_column(kwargs.pop("close", "b")) result = cross(series_a=a, series_b=b, above=above, asint=asint, offset=offset, **kwargs) - # self._add_prefix_suffix(result, **kwargs) - # self._append(result, **kwargs) return self._post_process(result, **kwargs) def cross_value(self, value=None, above=True, asint=True, offset=None, **kwargs): a = self._get_column(a, f"{a}") result = cross_value(series_a=a, value=value, above=above, asint=asint, offset=offset, **kwargs) - - # self._add_prefix_suffix(result, **kwargs) - # self._append(result, **kwargs) return self._post_process(result, **kwargs) # Volatility @@ -1369,7 +1479,6 @@ class AnalysisIndicators(BasePandasObject): high = self._get_column(kwargs.pop("high", "high")) low = self._get_column(kwargs.pop("low", "low")) close = self._get_column(kwargs.pop("close", "close")) - result = aberration(high=high, low=low, close=close, length=length, atr_length=atr_length, offset=offset, **kwargs) return self._post_process(result, **kwargs) @@ -1377,7 +1486,6 @@ class AnalysisIndicators(BasePandasObject): high = self._get_column(kwargs.pop("high", "high")) low = self._get_column(kwargs.pop("low", "low")) close = self._get_column(kwargs.pop("close", "close")) - result = accbands(high=high, low=low, close=close, length=length, c=c, mamode=mamode, offset=offset, **kwargs) return self._post_process(result, **kwargs) @@ -1385,7 +1493,6 @@ class AnalysisIndicators(BasePandasObject): high = self._get_column(kwargs.pop("high", "high")) low = self._get_column(kwargs.pop("low", "low")) close = self._get_column(kwargs.pop("close", "close")) - result = atr(high=high, low=low, close=close, length=length, mamode=mamode, offset=offset, **kwargs) return self._post_process(result, **kwargs) @@ -1397,22 +1504,24 @@ class AnalysisIndicators(BasePandasObject): def donchian(self, lower_length=None, upper_length=None, offset=None, **kwargs): high = self._get_column(kwargs.pop("high", "high")) low = self._get_column(kwargs.pop("low", "low")) - result = donchian(high=high, low=low, lower_length=lower_length, upper_length=upper_length, offset=offset, **kwargs) return self._post_process(result, **kwargs) + def hwc(self, na=None, nb=None, nc=None, nd=None, scalar=None, offset=None, **kwargs): + close = self._get_column(kwargs.pop("close", "close")) + result = hwc(close=close, na=na, nb=nb, nc=nc, nd=nd, scalar=scalar, offset=offset, **kwargs) + return self._post_process(result, **kwargs) + def kc(self, length=None, scalar=None, mamode=None, offset=None, **kwargs): high = self._get_column(kwargs.pop("high", "high")) low = self._get_column(kwargs.pop("low", "low")) close = self._get_column(kwargs.pop("close", "close")) - result = kc(high=high, low=low, close=close, length=length, scalar=scalar, mamode=mamode, offset=offset, **kwargs) return self._post_process(result, **kwargs) def massi(self, fast=None, slow=None, offset=None, **kwargs): high = self._get_column(kwargs.pop("high", "high")) low = self._get_column(kwargs.pop("low", "low")) - result = massi(high=high, low=low, fast=fast, slow=slow, offset=offset, **kwargs) return self._post_process(result, **kwargs) @@ -1420,7 +1529,6 @@ class AnalysisIndicators(BasePandasObject): high = self._get_column(kwargs.pop("high", "high")) low = self._get_column(kwargs.pop("low", "low")) close = self._get_column(kwargs.pop("close", "close")) - result = natr(high=high, low=low, close=close, length=length, mamode=mamode, scalar=scalar, offset=offset, **kwargs) return self._post_process(result, **kwargs) @@ -1429,7 +1537,6 @@ class AnalysisIndicators(BasePandasObject): high = self._get_column(kwargs.pop("high", "high")) low = self._get_column(kwargs.pop("low", "low")) close = self._get_column(kwargs.pop("close", "close")) - result = pdist(open_=open_, high=high, low=low, close=close, drift=drift, offset=offset, **kwargs) return self._post_process(result, **kwargs) @@ -1437,14 +1544,12 @@ class AnalysisIndicators(BasePandasObject): high = self._get_column(kwargs.pop("high", "high")) low = self._get_column(kwargs.pop("low", "low")) close = self._get_column(kwargs.pop("close", "close")) - result = rvi(high=high, low=low, close=close, length=length, scalar=scalar, refined=refined, thirds=thirds, mamode=mamode, drift=drift, offset=offset, **kwargs) return self._post_process(result, **kwargs) def thermo(self, long=None, short= None, length=None, mamode=None, drift=None, offset=None, **kwargs): high = self._get_column(kwargs.pop("high", "high")) low = self._get_column(kwargs.pop("low", "low")) - result = thermo(high=high, low=low, long=long, short=short, length=length, mamode=mamode, drift=drift, offset=offset, **kwargs) return self._post_process(result, **kwargs) @@ -1452,7 +1557,6 @@ class AnalysisIndicators(BasePandasObject): high = self._get_column(kwargs.pop("high", "high")) low = self._get_column(kwargs.pop("low", "low")) close = self._get_column(kwargs.pop("close", "close")) - result = true_range(high=high, low=low, close=close, drift=drift, offset=offset, **kwargs) return self._post_process(result, **kwargs) @@ -1469,7 +1573,6 @@ class AnalysisIndicators(BasePandasObject): low = self._get_column(kwargs.pop("low", "low")) close = self._get_column(kwargs.pop("close", "close")) volume = self._get_column(kwargs.pop("volume", "volume")) - result = ad(high=high, low=low, close=close, volume=volume, open_=open_, signed=signed, offset=offset, **kwargs) return self._post_process(result, **kwargs) @@ -1480,14 +1583,12 @@ class AnalysisIndicators(BasePandasObject): low = self._get_column(kwargs.pop("low", "low")) close = self._get_column(kwargs.pop("close", "close")) volume = self._get_column(kwargs.pop("volume", "volume")) - result = adosc(high=high, low=low, close=close, volume=volume, open_=open_, fast=fast, slow=slow, signed=signed, offset=offset, **kwargs) return self._post_process(result, **kwargs) def aobv(self, fast=None, slow=None, mamode=None, max_lookback=None, min_lookback=None, offset=None, **kwargs): close = self._get_column(kwargs.pop("close", "close")) volume = self._get_column(kwargs.pop("volume", "volume")) - result = aobv(close=close, volume=volume, fast=fast, slow=slow, mamode=mamode, max_lookback=max_lookback, min_lookback=min_lookback, offset=offset, **kwargs) return self._post_process(result, **kwargs) @@ -1498,14 +1599,12 @@ class AnalysisIndicators(BasePandasObject): low = self._get_column(kwargs.pop("low", "low")) close = self._get_column(kwargs.pop("close", "close")) volume = self._get_column(kwargs.pop("volume", "volume")) - result = cmf(high=high, low=low, close=close, volume=volume, open_=open_, length=length, offset=offset, **kwargs) return self._post_process(result, **kwargs) def efi(self, length=None, mamode=None, offset=None, drift=None, **kwargs): close = self._get_column(kwargs.pop("close", "close")) volume = self._get_column(kwargs.pop("volume", "volume")) - result = efi(close=close, volume=volume, length=length, offset=offset, mamode=mamode, drift=drift, **kwargs) return self._post_process(result, **kwargs) @@ -1514,7 +1613,6 @@ class AnalysisIndicators(BasePandasObject): low = self._get_column(kwargs.pop("low", "low")) close = self._get_column(kwargs.pop("close", "close")) volume = self._get_column(kwargs.pop("volume", "volume")) - result = eom(high=high, low=low, close=close, volume=volume, length=length, divisor=divisor, offset=offset, drift=drift, **kwargs) return self._post_process(result, **kwargs) @@ -1523,55 +1621,47 @@ class AnalysisIndicators(BasePandasObject): low = self._get_column(kwargs.pop("low", "low")) close = self._get_column(kwargs.pop("close", "close")) volume = self._get_column(kwargs.pop("volume", "volume")) - result = mfi(high=high, low=low, close=close, volume=volume, length=length, drift=drift, offset=offset, **kwargs) return self._post_process(result, **kwargs) def nvi(self, length=None, initial=None, signed=True, offset=None, **kwargs): close = self._get_column(kwargs.pop("close", "close")) volume = self._get_column(kwargs.pop("volume", "volume")) - result = nvi(close=close, volume=volume, length=length, initial=initial, signed=signed, offset=offset, **kwargs) return self._post_process(result, **kwargs) def obv(self, offset=None, **kwargs): close = self._get_column(kwargs.pop("close", "close")) volume = self._get_column(kwargs.pop("volume", "volume")) - result = obv(close=close, volume=volume, offset=offset, **kwargs) return self._post_process(result, **kwargs) def pvi(self, length=None, initial=None, signed=True, offset=None, **kwargs): close = self._get_column(kwargs.pop("close", "close")) volume = self._get_column(kwargs.pop("volume", "volume")) - result = pvi(close=close, volume=volume, length=length, initial=initial, signed=signed, offset=offset, **kwargs) return self._post_process(result, **kwargs) def pvol(self, volume=None, offset=None, **kwargs): close = self._get_column(kwargs.pop("close", "close")) volume = self._get_column(kwargs.pop("volume", "volume")) - result = pvol(close=close, volume=volume, offset=offset, **kwargs) return self._post_process(result, **kwargs) def pvr(self, **kwargs): close = self._get_column(kwargs.pop("close", "close")) volume = self._get_column(kwargs.pop("volume", "volume")) - result = pvr(close=close, volume=volume) return self._post_process(result, **kwargs) def pvt(self, offset=None, **kwargs): close = self._get_column(kwargs.pop("close", "close")) volume = self._get_column(kwargs.pop("volume", "volume")) - result = pvt(close=close, volume=volume, offset=offset, **kwargs) return self._post_process(result, **kwargs) def vp(self, width=None, percent=None, **kwargs): close = self._get_column(kwargs.pop("close", "close")) volume = self._get_column(kwargs.pop("volume", "volume")) - result = vp(close=close, volume=volume, width=width, percent=percent, **kwargs) return self._post_process(result, **kwargs) diff --git a/pandas_ta/cycles/__init__.py b/pandas_ta/cycles/__init__.py new file mode 100644 index 0000000..65bf123 --- /dev/null +++ b/pandas_ta/cycles/__init__.py @@ -0,0 +1,2 @@ +# -*- coding: utf-8 -*- +from .ebsw import ebsw diff --git a/pandas_ta/cycles/ebsw.py b/pandas_ta/cycles/ebsw.py new file mode 100644 index 0000000..01bfb51 --- /dev/null +++ b/pandas_ta/cycles/ebsw.py @@ -0,0 +1,115 @@ +# -*- coding: utf-8 -*- +from numpy import cos as npCos +from numpy import exp as npExp +from numpy import NaN as npNaN +from numpy import pi as npPi +from numpy import sin as npSin +from numpy import sqrt as npSqrt +from pandas import Series +from pandas_ta.utils import get_offset, verify_series + + +def ebsw(close, length=None, bars=None, offset=None, **kwargs): + """Indicator: Even Better SineWave (EBSW)""" + # Validate arguments + length = int(length) if length and length > 38 else 40 + bars = int(bars) if bars and bars > 0 else 10 + close = verify_series(close, length) + offset = get_offset(offset) + + if close is None: return + + # variables + alpha1 = HP = 0 # alpha and HighPass + a1 = b1 = c1 = c2 = c3 = 0 + Filt = Pwr = Wave = 0 + + lastClose = lastHP = 0 + FilterHist = [0, 0] # Filter history + + # Calculate Result + m = close.size + result = [npNaN for _ in range(0, length - 1)] + [0] + for i in range(length, m): + # HighPass filter cyclic components whose periods are shorter than Duration input + alpha1 = (1 - npSin(360 / length)) / npCos(360 / length) + HP = 0.5 * (1 + alpha1) * (close[i] - lastClose) + alpha1 * lastHP + + # Smooth with a Super Smoother Filter from equation 3-3 + a1 = npExp(-npSqrt(2) * npPi / bars) + b1 = 2 * a1 * npCos(npSqrt(2) * 180 / bars) + c2 = b1 + c3 = -1 * a1 * a1 + c1 = 1 - c2 - c3 + Filt = c1 * (HP + lastHP) / 2 + c2 * FilterHist[1] + c3 * FilterHist[0] + # Filt = float("{:.8f}".format(float(Filt))) # to fix for small scientific notations, the big ones fail + + # 3 Bar average of Wave amplitude and power + Wave = (Filt + FilterHist[1] + FilterHist[0]) / 3 + Pwr = (Filt * Filt + FilterHist[1] * FilterHist[1] + FilterHist[0] * FilterHist[0]) / 3 + + # Normalize the Average Wave to Square Root of the Average Power + Wave = Wave / npSqrt(Pwr) + + # update storage, result + FilterHist.append(Filt) # append new Filt value + FilterHist.pop(0) # remove first element of list (left) -> updating/trim + lastHP = HP + lastClose = close[i] + result.append(Wave) + + ebsw = Series(result, index=close.index) + + # Offset + if offset != 0: + ebsw = ebsw.shift(offset) + + # Handle fills + if "fillna" in kwargs: + ebsw.fillna(kwargs["fillna"], inplace=True) + if "fill_method" in kwargs: + ebsw.fillna(method=kwargs["fill_method"], inplace=True) + + # Name and Categorize it + ebsw.name = f"EBSW_{length}_{bars}" + ebsw.category = "cycles" + + return ebsw + + +ebsw.__doc__ = \ +"""Even Better SineWave (EBSW) *beta* + +This indicator measures market cycles and uses a low pass filter to remove noise. +Its output is bound signal between -1 and 1 and the maximum length of a detected +trend is limited by its length input. + +Written by rengel8 for Pandas TA based on a publication at 'prorealcode.com' and +a book by J.F.Ehlers. + +* This implementation seems to be logically limited. It would make sense to +implement exactly the version from prorealcode and compare the behaviour. + + +Sources: + https://www.prorealcode.com/prorealtime-indicators/even-better-sinewave/ + J.F.Ehlers 'Cycle Analytics for Traders', 2014 + +Calculation: + refer to 'sources' or implementation + +Args: + close (pd.Series): Series of 'close's + length (int): It's max cycle/trend period. Values between 40-48 work like + expected with minimum value: 39. Default: 40. + bars (int): Period of low pass filtering. Default: 10 + drift (int): The difference period. Default: 1 + offset (int): How many periods to offset the result. Default: 0 + +Kwargs: + fillna (value, optional): pd.DataFrame.fillna(value) + fill_method (value, optional): Type of fill method + +Returns: + pd.Series: New feature generated. +""" diff --git a/pandas_ta/momentum/__init__.py b/pandas_ta/momentum/__init__.py index 5384434..ded8f90 100644 --- a/pandas_ta/momentum/__init__.py +++ b/pandas_ta/momentum/__init__.py @@ -31,6 +31,7 @@ from .smi import smi from .squeeze import squeeze from .stoch import stoch from .stochrsi import stochrsi +from .td_seq import td_seq from .trix import trix from .tsi import tsi from .uo import uo diff --git a/pandas_ta/momentum/ao.py b/pandas_ta/momentum/ao.py index 3d77822..082ee90 100644 --- a/pandas_ta/momentum/ao.py +++ b/pandas_ta/momentum/ao.py @@ -6,14 +6,17 @@ from pandas_ta.utils import get_offset, verify_series def ao(high, low, fast=None, slow=None, offset=None, **kwargs): """Indicator: Awesome Oscillator (AO)""" # Validate Arguments - high = verify_series(high) - low = verify_series(low) fast = int(fast) if fast and fast > 0 else 5 slow = int(slow) if slow and slow > 0 else 34 if slow < fast: fast, slow = slow, fast + _length = max(fast, slow) + high = verify_series(high, _length) + low = verify_series(low, _length) offset = get_offset(offset) + if high is None or low is None: return + # Calculate Result median_price = 0.5 * (high + low) fast_sma = sma(median_price, fast) @@ -57,9 +60,9 @@ Calculation: Args: high (pd.Series): Series of 'high's low (pd.Series): Series of 'low's - fast (int): The short period. Default: 5 - slow (int): The long period. Default: 34 - offset (int): How many periods to offset the result. Default: 0 + fast (int): The short period. Default: 5 + slow (int): The long period. Default: 34 + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/momentum/apo.py b/pandas_ta/momentum/apo.py index 862165b..1d73cff 100644 --- a/pandas_ta/momentum/apo.py +++ b/pandas_ta/momentum/apo.py @@ -6,13 +6,15 @@ from pandas_ta.utils import get_offset, verify_series def apo(close, fast=None, slow=None, offset=None, **kwargs): """Indicator: Absolute Price Oscillator (APO)""" # Validate Arguments - close = verify_series(close) fast = int(fast) if fast and fast > 0 else 12 slow = int(slow) if slow and slow > 0 else 26 if slow < fast: fast, slow = slow, fast + close = verify_series(close, max(fast, slow)) offset = get_offset(offset) + if close is None: return + # Calculate Result fastma = sma(close, length=fast) slowma = sma(close, length=slow) @@ -40,7 +42,7 @@ apo.__doc__ = \ The Absolute Price Oscillator is an indicator used to measure a security's momentum. It is simply the difference of two Exponential Moving Averages -(EMA) of two different periods. Note: APO and MACD lines are equivalent. +(EMA) of two different periods. Note: APO and MACD lines are equivalent. Sources: https://www.tradingtechnologies.com/xtrader-help/x-study/technical-indicator-definitions/absolute-price-oscillator-apo/ @@ -53,9 +55,9 @@ Calculation: Args: close (pd.Series): Series of 'close's - fast (int): The short period. Default: 12 - slow (int): The long period. Default: 26 - offset (int): How many periods to offset the result. Default: 0 + fast (int): The short period. Default: 12 + slow (int): The long period. Default: 26 + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/momentum/bias.py b/pandas_ta/momentum/bias.py index 8d4e1d8..093dbea 100644 --- a/pandas_ta/momentum/bias.py +++ b/pandas_ta/momentum/bias.py @@ -6,11 +6,13 @@ from pandas_ta.utils import get_offset, verify_series def bias(close, length=None, mamode=None, offset=None, **kwargs): """Indicator: Bias (BIAS)""" # Validate Arguments - close = verify_series(close) length = int(length) if length and length > 0 else 26 mamode = mamode if isinstance(mamode, str) else "sma" + close = verify_series(close, length) offset = get_offset(offset) + if close is None: return + # Calculate Result bma = ma(mamode, close, length=length, **kwargs) bias = (close / bma) - 1 @@ -50,10 +52,10 @@ Calculation: Args: close (pd.Series): Series of 'close's - length (int): The period. Default: 26 - mamode (str): Options: 'ema', 'hma', 'rma', 'sma', 'wma'. Default: 'sma' - drift (int): The short period. Default: 1 - offset (int): How many periods to offset the result. Default: 0 + length (int): The period. Default: 26 + mamode (str): Options: 'ema', 'hma', 'rma', 'sma', 'wma'. Default: 'sma' + drift (int): The short period. Default: 1 + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/momentum/brar.py b/pandas_ta/momentum/brar.py index db82290..c5eb55c 100644 --- a/pandas_ta/momentum/brar.py +++ b/pandas_ta/momentum/brar.py @@ -6,17 +6,19 @@ from pandas_ta.utils import get_drift, get_offset, non_zero_range, verify_series def brar(open_, high, low, close, length=None, scalar=None, drift=None, offset=None, **kwargs): """Indicator: BRAR (BRAR)""" # Validate Arguments - open_ = verify_series(open_) - high = verify_series(high) - low = verify_series(low) - close = verify_series(close) length = int(length) if length and length > 0 else 26 scalar = float(scalar) if scalar else 100 high_open_range = non_zero_range(high, open_) open_low_range = non_zero_range(open_, low) + open_ = verify_series(open_, length) + high = verify_series(high, length) + low = verify_series(low, length) + close = verify_series(close, length) drift = get_drift(drift) offset = get_offset(offset) + if open_ is None or high is None or low is None or close is None: return + # Calculate Result hcy = non_zero_range(high, close.shift(drift)) cyl = non_zero_range(close.shift(drift), low) @@ -85,10 +87,10 @@ Args: high (pd.Series): Series of 'high's low (pd.Series): Series of 'low's close (pd.Series): Series of 'close's - length (int): The period. Default: 26 - scalar (float): How much to magnify. Default: 100 - drift (int): The difference period. Default: 1 - offset (int): How many periods to offset the result. Default: 0 + length (int): The period. Default: 26 + scalar (float): How much to magnify. Default: 100 + drift (int): The difference period. Default: 1 + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/momentum/cci.py b/pandas_ta/momentum/cci.py index 6456a1f..df5ab85 100644 --- a/pandas_ta/momentum/cci.py +++ b/pandas_ta/momentum/cci.py @@ -7,13 +7,15 @@ from pandas_ta.utils import get_offset, verify_series def cci(high, low, close, length=None, c=None, offset=None, **kwargs): """Indicator: Commodity Channel Index (CCI)""" # Validate Arguments - high = verify_series(high) - low = verify_series(low) - close = verify_series(close) length = int(length) if length and length > 0 else 14 c = float(c) if c and c > 0 else 0.015 + high = verify_series(high, length) + low = verify_series(low, length) + close = verify_series(close, length) offset = get_offset(offset) + if high is None or low is None or close is None: return + # Calculate Result typical_price = hlc3(high=high, low=low, close=close) mean_typical_price = sma(typical_price, length=length) @@ -62,9 +64,9 @@ Args: high (pd.Series): Series of 'high's low (pd.Series): Series of 'low's close (pd.Series): Series of 'close's - length (int): It's period. Default: 14 - c (float): Scaling Constant. Default: 0.015 - offset (int): How many periods to offset the result. Default: 0 + length (int): It's period. Default: 14 + c (float): Scaling Constant. Default: 0.015 + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/momentum/cfo.py b/pandas_ta/momentum/cfo.py index a0f1afe..f5ae491 100644 --- a/pandas_ta/momentum/cfo.py +++ b/pandas_ta/momentum/cfo.py @@ -6,12 +6,14 @@ from pandas_ta.utils import get_drift, get_offset, verify_series def cfo(close, length=None, scalar=None, drift=None, offset=None, **kwargs): """Indicator: Chande Forcast Oscillator (CFO)""" # Validate Arguments - close = verify_series(close) length = int(length) if length and length > 0 else 9 scalar = float(scalar) if scalar else 100 + close = verify_series(close, length) drift = get_drift(drift) offset = get_offset(offset) + if close is None: return + # Finding linear regression of Series cfo = scalar * (close - linreg(close, length=length, tsf=True)) cfo /= close diff --git a/pandas_ta/momentum/cg.py b/pandas_ta/momentum/cg.py index ed99166..868fefe 100644 --- a/pandas_ta/momentum/cg.py +++ b/pandas_ta/momentum/cg.py @@ -5,10 +5,12 @@ from pandas_ta.utils import get_offset, verify_series, weights def cg(close, length=None, offset=None, **kwargs): """Indicator: Center of Gravity (CG)""" # Validate Arguments - close = verify_series(close) length = int(length) if length and length > 0 else 10 + close = verify_series(close, length) offset = get_offset(offset) + if close is None: return + # Calculate Result coefficients = [length - i for i in range(0, length)] numerator = -close.rolling(length).apply(weights(coefficients), raw=True) @@ -46,8 +48,8 @@ Calculation: Args: close (pd.Series): Series of 'close's - length (int): The length of the period. Default: 10 - offset (int): How many periods to offset the result. Default: 0 + length (int): The length of the period. Default: 10 + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/momentum/cmo.py b/pandas_ta/momentum/cmo.py index 442b5b4..52ddca6 100644 --- a/pandas_ta/momentum/cmo.py +++ b/pandas_ta/momentum/cmo.py @@ -6,18 +6,20 @@ from pandas_ta.utils import get_drift, get_offset, verify_series def cmo(close, length=None, scalar=None, drift=None, offset=None, **kwargs): """Indicator: Chande Momentum Oscillator (CMO)""" # Validate Arguments - close = verify_series(close) length = int(length) if length and length > 0 else 14 scalar = float(scalar) if scalar else 100 - talib = kwargs.pop("talib", True) + close = verify_series(close, length) drift = get_drift(drift) offset = get_offset(offset) + if close is None: return + # Calculate Result mom = close.diff(drift) positive = mom.copy().clip(lower=0) negative = mom.copy().clip(upper=0).abs() + talib = kwargs.pop("talib", True) if talib: pos_ = rma(positive, length) neg_ = rma(negative, length) diff --git a/pandas_ta/momentum/coppock.py b/pandas_ta/momentum/coppock.py index 0ae42ea..a4f3a08 100644 --- a/pandas_ta/momentum/coppock.py +++ b/pandas_ta/momentum/coppock.py @@ -7,12 +7,14 @@ from pandas_ta.utils import get_offset, verify_series def coppock(close, length=None, fast=None, slow=None, offset=None, **kwargs): """Indicator: Coppock Curve (COPC)""" # Validate Arguments - close = verify_series(close) length = int(length) if length and length > 0 else 10 fast = int(fast) if fast and fast > 0 else 11 slow = int(slow) if slow and slow > 0 else 14 + close = verify_series(close, max(length, fast, slow)) offset = get_offset(offset) + if close is None: return + # Calculate Result total_roc = roc(close, fast) + roc(close, slow) coppock = wma(total_roc, length) @@ -58,10 +60,10 @@ Calculation: Args: close (pd.Series): Series of 'close's - length (int): WMA period. Default: 10 - fast (int): Fast ROC period. Default: 11 - slow (int): Slow ROC period. Default: 14 - offset (int): How many periods to offset the result. Default: 0 + length (int): WMA period. Default: 10 + fast (int): Fast ROC period. Default: 11 + slow (int): Slow ROC period. Default: 14 + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/momentum/er.py b/pandas_ta/momentum/er.py index 26e6da3..bd4773f 100644 --- a/pandas_ta/momentum/er.py +++ b/pandas_ta/momentum/er.py @@ -6,11 +6,13 @@ from pandas_ta.utils import get_drift, get_offset, verify_series, signals def er(close, length=None, drift=None, offset=None, **kwargs): """Indicator: Efficiency Ratio (ER)""" # Validate arguments - close = verify_series(close) length = int(length) if length and length > 0 else 10 + close = verify_series(close, length) offset = get_offset(offset) drift = get_drift(drift) + if close is None: return + # Calculate Result abs_diff = close.diff(length).abs() abs_volatility = close.diff(drift).abs() @@ -79,8 +81,8 @@ Calculation: Args: close (pd.Series): Series of 'close's - length (int): It's period. Default: 1 - offset (int): How many periods to offset the result. Default: 0 + length (int): It's period. Default: 1 + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/momentum/eri.py b/pandas_ta/momentum/eri.py index e2c3490..6e947c5 100644 --- a/pandas_ta/momentum/eri.py +++ b/pandas_ta/momentum/eri.py @@ -7,12 +7,14 @@ from pandas_ta.utils import get_offset, verify_series def eri(high, low, close, length=None, offset=None, **kwargs): """Indicator: Elder Ray Index (ERI)""" # Validate arguments - high = verify_series(high) - low = verify_series(low) - close = verify_series(close) length = int(length) if length and length > 0 else 13 + high = verify_series(high, length) + low = verify_series(low, length) + close = verify_series(close, length) offset = get_offset(offset) + if high is None or low is None or close is None: return + # Calculate Result ema_ = ema(close, length) bull = high - ema_ @@ -73,8 +75,8 @@ Args: high (pd.Series): Series of 'high's low (pd.Series): Series of 'low's close (pd.Series): Series of 'close's - length (int): It's period. Default: 14 - offset (int): How many periods to offset the result. Default: 0 + length (int): It's period. Default: 14 + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/momentum/fisher.py b/pandas_ta/momentum/fisher.py index 197577a..f097637 100644 --- a/pandas_ta/momentum/fisher.py +++ b/pandas_ta/momentum/fisher.py @@ -9,12 +9,15 @@ from pandas_ta.utils import get_offset, high_low_range, verify_series, zero def fisher(high, low, length=None, signal=None, offset=None, **kwargs): """Indicator: Fisher Transform (FISHT)""" # Validate Arguments - high = verify_series(high) - low = verify_series(low) length = int(length) if length and length > 0 else 9 signal = int(signal) if signal and signal > 0 else 1 + _length = max(length, signal) + high = verify_series(high, _length) + low = verify_series(low, _length) offset = get_offset(offset) + if high is None or low is None: return + # Calculate Result hl2_ = hl2(high, low) highest_hl2 = hl2_.rolling(length).max() @@ -29,7 +32,7 @@ def fisher(high, low, length=None, signal=None, offset=None, **kwargs): m = high.size result = [npNaN for _ in range(0, length - 1)] + [0] for i in range(length, m): - v = 0.66 * position[i] + 0.67 * v + v = 0.66 * position.iloc[i] + 0.67 * v if v < -0.99: v = -0.999 if v > 0.99: @@ -102,9 +105,9 @@ Calculation: Args: high (pd.Series): Series of 'high's low (pd.Series): Series of 'low's - length (int): Fisher period. Default: 9 - signal (int): Fisher Signal period. Default: 1 - offset (int): How many periods to offset the result. Default: 0 + length (int): Fisher period. Default: 9 + signal (int): Fisher Signal period. Default: 1 + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/momentum/inertia.py b/pandas_ta/momentum/inertia.py index 41cb6b9..e76428e 100644 --- a/pandas_ta/momentum/inertia.py +++ b/pandas_ta/momentum/inertia.py @@ -1,25 +1,29 @@ # -*- coding: utf-8 -*- from pandas_ta.overlap import linreg from pandas_ta.volatility import rvi -from pandas_ta.utils import get_drift, get_offset, non_zero_range, verify_series +from pandas_ta.utils import get_drift, get_offset, verify_series def inertia(close=None, high=None, low=None, length=None, rvi_length=None, scalar=None, refined=None, thirds=None, mamode=None, drift=None, offset=None, **kwargs): """Indicator: Inertia (INERTIA)""" # Validate Arguments - close = verify_series(close) length = int(length) if length and length > 0 else 20 rvi_length = int(rvi_length) if rvi_length and rvi_length > 0 else 14 scalar = float(scalar) if scalar and scalar > 0 else 100 refined = False if refined is None else True thirds = False if thirds is None else True mamode = mamode if isinstance(mamode, str) else "ema" + _length = max(length, rvi_length) + close = verify_series(close, _length) drift = get_drift(drift) offset = get_offset(offset) + if close is None: return + if refined or thirds: - high = verify_series(high) - low = verify_series(low) + high = verify_series(high, _length) + low = verify_series(low, _length) + if high is None or low is None: return # Calculate Result if refined: @@ -75,10 +79,10 @@ Args: high (pd.Series): Series of 'high's low (pd.Series): Series of 'low's close (pd.Series): Series of 'close's - length (int): It's period. Default: 20 - rvi_length (int): RVI period. Default: 14 - drift (int): The difference period. Default: 1 - offset (int): How many periods to offset the result. Default: 0 + length (int): It's period. Default: 20 + rvi_length (int): RVI period. Default: 14 + drift (int): The difference period. Default: 1 + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/momentum/kdj.py b/pandas_ta/momentum/kdj.py index 88175c1..f941e28 100644 --- a/pandas_ta/momentum/kdj.py +++ b/pandas_ta/momentum/kdj.py @@ -7,13 +7,16 @@ from pandas_ta.utils import get_offset, non_zero_range, verify_series def kdj(high=None, low=None, close=None, length=None, signal=None, offset=None, **kwargs): """Indicator: KDJ (KDJ)""" # Validate Arguments - high = verify_series(high) - low = verify_series(low) - close = verify_series(close) length = int(length) if length and length > 0 else 9 signal = int(signal) if signal and signal > 0 else 3 + _length = max(length, signal) + high = verify_series(high, _length) + low = verify_series(low, _length) + close = verify_series(close, _length) offset = get_offset(offset) + if high is None or low is None or close is None: return + # Calculate Result highest_high = high.rolling(length).max() lowest_low = low.rolling(length).min() @@ -86,7 +89,7 @@ Args: close (pd.Series): Series of 'close's length (int): Default: 9 signal (int): Default: 3 - offset (int): How many periods to offset the result. Default: 0 + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/momentum/kst.py b/pandas_ta/momentum/kst.py index f91c84b..0319b24 100644 --- a/pandas_ta/momentum/kst.py +++ b/pandas_ta/momentum/kst.py @@ -7,7 +7,6 @@ from pandas_ta.utils import get_drift, get_offset, verify_series def kst(close, roc1=None, roc2=None, roc3=None, roc4=None, sma1=None, sma2=None, sma3=None, sma4=None, signal=None, drift=None, offset=None, **kwargs): """Indicator: 'Know Sure Thing' (KST)""" # Validate arguments - close = verify_series(close) roc1 = int(roc1) if roc1 and roc1 > 0 else 10 roc2 = int(roc2) if roc2 and roc2 > 0 else 15 roc3 = int(roc3) if roc3 and roc3 > 0 else 20 @@ -19,9 +18,13 @@ def kst(close, roc1=None, roc2=None, roc3=None, roc4=None, sma1=None, sma2=None, sma4 = int(sma4) if sma4 and sma4 > 0 else 15 signal = int(signal) if signal and signal > 0 else 9 + _length = max(roc1, roc2, roc3, roc4, sma1, sma2, sma3, sma4, signal) + close = verify_series(close, _length) drift = get_drift(drift) offset = get_offset(offset) + if close is None: return + # Calculate Result rocma1 = roc(close, roc1).rolling(sma1).mean() rocma2 = roc(close, roc2).rolling(sma2).mean() @@ -83,17 +86,17 @@ Calculation: Args: close (pd.Series): Series of 'close's - roc1 (int): ROC 1 period. Default: 10 - roc2 (int): ROC 2 period. Default: 15 - roc3 (int): ROC 3 period. Default: 20 - roc4 (int): ROC 4 period. Default: 30 - sma1 (int): SMA 1 period. Default: 10 - sma2 (int): SMA 2 period. Default: 10 - sma3 (int): SMA 3 period. Default: 10 - sma4 (int): SMA 4 period. Default: 15 - signal (int): It's period. Default: 9 - drift (int): The difference period. Default: 1 - offset (int): How many periods to offset the result. Default: 0 + roc1 (int): ROC 1 period. Default: 10 + roc2 (int): ROC 2 period. Default: 15 + roc3 (int): ROC 3 period. Default: 20 + roc4 (int): ROC 4 period. Default: 30 + sma1 (int): SMA 1 period. Default: 10 + sma2 (int): SMA 2 period. Default: 10 + sma3 (int): SMA 3 period. Default: 10 + sma4 (int): SMA 4 period. Default: 15 + signal (int): It's period. Default: 9 + drift (int): The difference period. Default: 1 + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/momentum/macd.py b/pandas_ta/momentum/macd.py index d23f49b..1a9ca47 100644 --- a/pandas_ta/momentum/macd.py +++ b/pandas_ta/momentum/macd.py @@ -1,5 +1,5 @@ # -*- coding: utf-8 -*- -from pandas import DataFrame, concat +from pandas import concat, DataFrame from pandas_ta.overlap import ema from pandas_ta.utils import get_offset, verify_series, signals @@ -7,14 +7,16 @@ from pandas_ta.utils import get_offset, verify_series, signals def macd(close, fast=None, slow=None, signal=None, offset=None, **kwargs): """Indicator: Moving Average, Convergence/Divergence (MACD)""" # Validate arguments - close = verify_series(close) fast = int(fast) if fast and fast > 0 else 12 slow = int(slow) if slow and slow > 0 else 26 signal = int(signal) if signal and signal > 0 else 9 if slow < fast: fast, slow = slow, fast + close = verify_series(close, max(fast, slow, signal)) offset = get_offset(offset) + if close is None: return + # Calculate Result fastma = ema(close, length=fast) slowma = ema(close, length=slow) @@ -93,7 +95,7 @@ macd.__doc__ = \ The MACD is a popular indicator to that is used to identify a security's trend. While APO and MACD are the same calculation, MACD also returns two more series -called Signal and Histogram. The Signal is an EMA of MACD and the Histogram is +called Signal and Histogram. The Signal is an EMA of MACD and the Histogram is the difference of MACD and Signal. Sources: @@ -109,10 +111,10 @@ Calculation: Args: close (pd.Series): Series of 'close's - fast (int): The short period. Default: 12 - slow (int): The long period. Default: 26 - signal (int): The signal period. Default: 9 - offset (int): How many periods to offset the result. Default: 0 + fast (int): The short period. Default: 12 + slow (int): The long period. Default: 26 + signal (int): The signal period. Default: 9 + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/momentum/mom.py b/pandas_ta/momentum/mom.py index ea1f950..c6d676a 100644 --- a/pandas_ta/momentum/mom.py +++ b/pandas_ta/momentum/mom.py @@ -5,10 +5,12 @@ from pandas_ta.utils import get_offset, verify_series def mom(close, length=None, offset=None, **kwargs): """Indicator: Momentum (MOM)""" # Validate Arguments - close = verify_series(close) length = int(length) if length and length > 0 else 10 + close = verify_series(close, length) offset = get_offset(offset) + if close is None: return + # Calculate Result mom = close.diff(length) @@ -45,8 +47,8 @@ Calculation: Args: close (pd.Series): Series of 'close's - length (int): It's period. Default: 1 - offset (int): How many periods to offset the result. Default: 0 + length (int): It's period. Default: 1 + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/momentum/pgo.py b/pandas_ta/momentum/pgo.py index 89912fc..6ede192 100644 --- a/pandas_ta/momentum/pgo.py +++ b/pandas_ta/momentum/pgo.py @@ -7,12 +7,14 @@ from pandas_ta.utils import get_offset, verify_series def pgo(high, low, close, length=None, offset=None, **kwargs): """Indicator: Pretty Good Oscillator (PGO)""" # Validate arguments - high = verify_series(high) - low = verify_series(low) - close = verify_series(close) length = int(length) if length and length > 0 else 14 + high = verify_series(high, length) + low = verify_series(low, length) + close = verify_series(close, length) offset = get_offset(offset) + if high is None or low is None or close is None: return + # Calculate Result pgo = close - sma(close, length) pgo /= ema(atr(high, low, close, length), length) @@ -57,8 +59,8 @@ Args: high (pd.Series): Series of 'high's low (pd.Series): Series of 'low's close (pd.Series): Series of 'close's - length (int): It's period. Default: 14 - offset (int): How many periods to offset the result. Default: 0 + length (int): It's period. Default: 14 + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/momentum/ppo.py b/pandas_ta/momentum/ppo.py index 829a62a..c15d736 100644 --- a/pandas_ta/momentum/ppo.py +++ b/pandas_ta/momentum/ppo.py @@ -7,15 +7,17 @@ from pandas_ta.utils import get_offset, verify_series def ppo(close, fast=None, slow=None, signal=None, scalar=None, offset=None, **kwargs): """Indicator: Percentage Price Oscillator (PPO)""" # Validate Arguments - close = verify_series(close) fast = int(fast) if fast and fast > 0 else 12 slow = int(slow) if slow and slow > 0 else 26 signal = int(signal) if signal and signal > 0 else 9 scalar = float(scalar) if scalar else 100 if slow < fast: fast, slow = slow, fast + close = verify_series(close, max(fast, slow, signal)) offset = get_offset(offset) + if close is None: return + # Calculate Result fastma = sma(close, length=fast) slowma = sma(close, length=slow) @@ -78,11 +80,11 @@ Calculation: Args: close(pandas.Series): Series of 'close's - fast(int): The short period. Default: 12 - slow(int): The long period. Default: 26 - signal(int): The signal period. Default: 9 - scalar (float): How much to magnify. Default: 100 - offset(int): How many periods to offset the result. Default: 0 + fast(int): The short period. Default: 12 + slow(int): The long period. Default: 26 + signal(int): The signal period. Default: 9 + scalar (float): How much to magnify. Default: 100 + offset(int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/momentum/psl.py b/pandas_ta/momentum/psl.py index 68b4468..3a4d84c 100644 --- a/pandas_ta/momentum/psl.py +++ b/pandas_ta/momentum/psl.py @@ -6,12 +6,14 @@ from pandas_ta.utils import get_drift, get_offset, verify_series def psl(close, open_=None, length=None, scalar=None, drift=None, offset=None, **kwargs): """Indicator: Psychological Line (PSL)""" # Validate Arguments - close = verify_series(close) length = int(length) if length and length > 0 else 12 scalar = float(scalar) if scalar and scalar > 0 else 100 + close = verify_series(close, length) drift = get_drift(drift) offset = get_offset(offset) + if close is None: return + # Calculate Result if open_ is not None: open_ = verify_series(open_) @@ -71,10 +73,10 @@ Calculation: Args: close (pd.Series): Series of 'close's open_ (pd.Series, optional): Series of 'open's - length (int): It's period. Default: 12 - scalar (float): How much to magnify. Default: 100 - drift (int): The difference period. Default: 1 - offset (int): How many periods to offset the result. Default: 0 + length (int): It's period. Default: 12 + scalar (float): How much to magnify. Default: 100 + drift (int): The difference period. Default: 1 + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/momentum/pvo.py b/pandas_ta/momentum/pvo.py index bd98eeb..5478cca 100644 --- a/pandas_ta/momentum/pvo.py +++ b/pandas_ta/momentum/pvo.py @@ -7,15 +7,17 @@ from pandas_ta.utils import get_offset, verify_series def pvo(volume, fast=None, slow=None, signal=None, scalar=None, offset=None, **kwargs): """Indicator: Percentage Volume Oscillator (PVO)""" # Validate Arguments - volume = verify_series(volume) fast = int(fast) if fast and fast > 0 else 12 slow = int(slow) if slow and slow > 0 else 26 signal = int(signal) if signal and signal > 0 else 9 scalar = float(scalar) if scalar else 100 if slow < fast: fast, slow = slow, fast + volume = verify_series(volume, max(fast, slow, signal)) offset = get_offset(offset) + if volume is None: return + # Calculate Result fastma = ema(volume, length=fast) slowma = ema(volume, length=slow) @@ -76,11 +78,11 @@ Calculation: Args: volume (pd.Series): Series of 'volume's - fast (int): The short period. Default: 12 - slow (int): The long period. Default: 26 - signal (int): The signal period. Default: 9 - scalar (float): How much to magnify. Default: 100 - offset (int): How many periods to offset the result. Default: 0 + fast (int): The short period. Default: 12 + slow (int): The long period. Default: 26 + signal (int): The signal period. Default: 9 + scalar (float): How much to magnify. Default: 100 + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/momentum/qqe.py b/pandas_ta/momentum/qqe.py index a5f2aea..1badab6 100644 --- a/pandas_ta/momentum/qqe.py +++ b/pandas_ta/momentum/qqe.py @@ -12,14 +12,17 @@ from pandas_ta.utils import get_drift, get_offset, verify_series def qqe(close, length=None, smooth=None, factor=None, mamode=None, drift=None, offset=None, **kwargs): """Indicator: Quantitative Qualitative Estimation (QQE)""" # Validate arguments - close = verify_series(close) length = int(length) if length and length > 0 else 14 smooth = int(smooth) if smooth and smooth > 0 else 5 factor = float(factor) if factor else 4.236 + wilders_length = 2 * length - 1 mamode = mamode if isinstance(mamode, str) else "ema" + close = verify_series(close, max(length, smooth, wilders_length)) drift = get_drift(drift) offset = get_offset(offset) + if close is None: return + # Calculate Result rsi_ = rsi(close, length) _mode = mamode.lower()[0] if mamode != "ema" else "" @@ -30,7 +33,6 @@ def qqe(close, length=None, smooth=None, factor=None, mamode=None, drift=None, o # Double Smooth the RSI MA True Range using Wilder's Length with a default # width of 4.236. - wilders_length = 2 * length - 1 smoothed_rsi_tr_ma = ma("ema", rsi_ma_tr, length=wilders_length) dar = factor * ma("ema", smoothed_rsi_tr_ma, length=wilders_length) @@ -131,7 +133,6 @@ Sources: https://www.tradingview.com/script/IYfA9R2k-QQE-MT4/ https://www.tradingpedia.com/forex-trading-indicators/quantitative-qualitative-estimation https://www.prorealcode.com/prorealtime-indicators/qqe-quantitative-qualitative-estimation/ - Calculation: Default Inputs: @@ -142,7 +143,8 @@ Args: length (int): RSI period. Default: 14 smooth (int): RSI smoothing period. Default: 5 factor (float): QQE Factor. Default: 4.236 - mamode (str): Smoothing MA type: "ema", "hma", "rma", "sma" or "wma". Default: "ema" + mamode (str): Smoothing MA type: "ema", "hma", "rma", "sma" or "wma". + Default: "ema" drift (int): The difference period. Default: 1 offset (int): How many periods to offset the result. Default: 0 diff --git a/pandas_ta/momentum/roc.py b/pandas_ta/momentum/roc.py index 9fff0fc..547519a 100644 --- a/pandas_ta/momentum/roc.py +++ b/pandas_ta/momentum/roc.py @@ -6,10 +6,12 @@ from pandas_ta.utils import get_offset, verify_series def roc(close, length=None, offset=None, **kwargs): """Indicator: Rate of Change (ROC)""" # Validate Arguments - close = verify_series(close) length = int(length) if length and length > 0 else 10 + close = verify_series(close, length) offset = get_offset(offset) + if close is None: return + # Calculate Result roc = 100 * mom(close=close, length=length) / close.shift(length) @@ -48,8 +50,8 @@ Calculation: Args: close (pd.Series): Series of 'close's - length (int): It's period. Default: 1 - offset (int): How many periods to offset the result. Default: 0 + length (int): It's period. Default: 1 + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/momentum/rsi.py b/pandas_ta/momentum/rsi.py index 2a18b4f..ee7e09e 100644 --- a/pandas_ta/momentum/rsi.py +++ b/pandas_ta/momentum/rsi.py @@ -7,12 +7,14 @@ from pandas_ta.utils import get_drift, get_offset, verify_series, signals def rsi(close, length=None, scalar=None, drift=None, offset=None, **kwargs): """Indicator: Relative Strength Index (RSI)""" # Validate arguments - close = verify_series(close) length = int(length) if length and length > 0 else 14 scalar = float(scalar) if scalar else 100 + close = verify_series(close, length) drift = get_drift(drift) offset = get_offset(offset) + if close is None: return + # Calculate Result negative = close.diff(drift) positive = negative.copy() diff --git a/pandas_ta/momentum/rsx.py b/pandas_ta/momentum/rsx.py index facfdc7..4ae6dbd 100644 --- a/pandas_ta/momentum/rsx.py +++ b/pandas_ta/momentum/rsx.py @@ -1,16 +1,19 @@ # -*- coding: utf-8 -*- from numpy import NaN as npNaN -from pandas import DataFrame, Series, concat +from pandas import concat, DataFrame, Series from pandas_ta.utils import get_drift, get_offset, verify_series, signals + def rsx(close, length=None, drift=None, offset=None, **kwargs): """Indicator: Relative Strength Xtra (inspired by Jurik RSX)""" # Validate arguments - close = verify_series(close) length = int(length) if length and length > 0 else 14 + close = verify_series(close, length) drift = get_drift(drift) offset = get_offset(offset) + if close is None: return + # variables vC, v1C = 0, 0 v4, v8, v10, v14, v18, v20 = 0, 0, 0, 0, 0, 0 @@ -30,7 +33,7 @@ def rsx(close, length=None, drift=None, offset=None, **kwargs): f88 = length - 1.0 else: f88 = 5.0 - f8 = 100.0 * close[i] + f8 = 100.0 * close.iloc[i] f18 = 3.0 / (length + 2.0) f20 = 1.0 - f18 else: @@ -39,7 +42,7 @@ def rsx(close, length=None, drift=None, offset=None, **kwargs): else: f90 = f90 + 1 f10 = f8 - f8 = 100 * close[i] + f8 = 100 * close.iloc[i] v8 = f8 - f10 f28 = f20 * f28 + f18 * v8 f30 = f18 * f28 + f20 * f30 diff --git a/pandas_ta/momentum/rvgi.py b/pandas_ta/momentum/rvgi.py index 9816c1f..9116eb4 100644 --- a/pandas_ta/momentum/rvgi.py +++ b/pandas_ta/momentum/rvgi.py @@ -7,16 +7,19 @@ from pandas_ta.utils import get_offset, non_zero_range, verify_series def rvgi(open_, high, low, close, length=None, swma_length=None, offset=None, **kwargs): """Indicator: Relative Vigor Index (RVGI)""" # Validate Arguments - open_ = verify_series(open_) - high = verify_series(high) - low = verify_series(low) - close = verify_series(close) high_low_range = non_zero_range(high, low) close_open_range = non_zero_range(close, open_) length = int(length) if length and length > 0 else 14 swma_length = int(swma_length) if swma_length and swma_length > 0 else 4 + _length = max(length, swma_length) + open_ = verify_series(open_, _length) + high = verify_series(high, _length) + low = verify_series(low, _length) + close = verify_series(close, _length) offset = get_offset(offset) + if open_ is None or high is None or low is None or close is None: return + # Calculate Result numerator = swma(close_open_range, length=swma_length).rolling(length).sum() denominator = swma(high_low_range, length=swma_length).rolling(length).sum() @@ -74,9 +77,9 @@ Args: high (pd.Series): Series of 'high's low (pd.Series): Series of 'low's close (pd.Series): Series of 'close's - length (int): It's period. Default: 14 - swma_length (int): It's period. Default: 4 - offset (int): How many periods to offset the result. Default: 0 + length (int): It's period. Default: 14 + swma_length (int): It's period. Default: 4 + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/momentum/slope.py b/pandas_ta/momentum/slope.py index 36b6f30..da09845 100644 --- a/pandas_ta/momentum/slope.py +++ b/pandas_ta/momentum/slope.py @@ -1,23 +1,26 @@ # -*- coding: utf-8 -*- -from math import atan, pi +from numpy import arctan as npAtan +from numpy import pi as npPi from pandas_ta.utils import get_offset, verify_series def slope( close, length=None, as_angle=None, to_degrees=None, vertical=None, offset=None, **kwargs): """Indicator: Slope""" # Validate arguments - close = verify_series(close) length = int(length) if length and length > 0 else 1 as_angle = True if isinstance(as_angle, bool) else False to_degrees = True if isinstance(to_degrees, bool) else False + close = verify_series(close, length) offset = get_offset(offset) + if close is None: return + # Calculate Result slope = close.diff(length) / length if as_angle: - slope = slope.apply(atan) + slope = slope.apply(npAtan) if to_degrees: - slope *= 180 / pi + slope *= 180 / npPi # Offset if offset != 0: @@ -39,7 +42,8 @@ def slope( close, length=None, as_angle=None, to_degrees=None, vertical=None, of slope.__doc__ = \ """Slope -Returns the slope of a series of length n. Can convert the slope to angle. Default: slope. +Returns the slope of a series of length n. Can convert the slope to angle. +Default: slope. Sources: Algebra I diff --git a/pandas_ta/momentum/smi.py b/pandas_ta/momentum/smi.py index 289deb1..a652cca 100644 --- a/pandas_ta/momentum/smi.py +++ b/pandas_ta/momentum/smi.py @@ -1,22 +1,24 @@ # -*- coding: utf-8 -*- -from pandas import concat, DataFrame +from pandas import DataFrame from .tsi import tsi from pandas_ta.overlap import ema -from pandas_ta.utils import get_offset, verify_series, signals +from pandas_ta.utils import get_offset, verify_series def smi(close, fast=None, slow=None, signal=None, scalar=None, offset=None, **kwargs): """Indicator: SMI Ergodic Indicator (SMIIO)""" # Validate arguments - close = verify_series(close) fast = int(fast) if fast and fast > 0 else 5 slow = int(slow) if slow and slow > 0 else 20 signal = int(signal) if signal and signal > 0 else 5 if slow < fast: fast, slow = slow, fast scalar = float(scalar) if scalar else 1 + close = verify_series(close, max(fast, slow, signal)) offset = get_offset(offset) + if close is None: return + # Calculate Result smi = tsi(close, fast=fast, slow=slow, scalar=scalar) signalma = ema(smi, signal) diff --git a/pandas_ta/momentum/squeeze.py b/pandas_ta/momentum/squeeze.py index 4f20773..64e6197 100644 --- a/pandas_ta/momentum/squeeze.py +++ b/pandas_ta/momentum/squeeze.py @@ -1,7 +1,6 @@ # -*- coding: utf-8 -*- from numpy import NaN as npNaN from pandas import DataFrame - from pandas_ta.momentum import mom from pandas_ta.overlap import ema, linreg, sma from pandas_ta.trend import decreasing, increasing @@ -13,17 +12,19 @@ from pandas_ta.utils import unsigned_differences, verify_series def squeeze(high, low, close, bb_length=None, bb_std=None, kc_length=None, kc_scalar=None, mom_length=None, mom_smooth=None, use_tr=None, offset=None, **kwargs): """Indicator: Squeeze Momentum (SQZ)""" # Validate arguments - high = verify_series(high) - low = verify_series(low) - close = verify_series(close) - offset = get_offset(offset) - bb_length = int(bb_length) if bb_length and bb_length > 0 else 20 bb_std = float(bb_std) if bb_std and bb_std > 0 else 2.0 kc_length = int(kc_length) if kc_length and kc_length > 0 else 20 kc_scalar = float(kc_scalar) if kc_scalar and kc_scalar > 0 else 1.5 mom_length = int(mom_length) if mom_length and mom_length > 0 else 12 mom_smooth = int(mom_smooth) if mom_smooth and mom_smooth > 0 else 6 + _length = max(bb_length, kc_length, mom_length, mom_smooth) + high = verify_series(high, _length) + low = verify_series(low, _length) + close = verify_series(close, _length) + offset = get_offset(offset) + + if high is None or low is None or close is None: return use_tr = kwargs.setdefault("tr", True) asint = kwargs.pop("asint", True) @@ -203,7 +204,7 @@ Args: mom_length (int): Momentum Period. Default: 12 mom_smooth (int): Smoothing Period of Momentum. Default: 6 mamode (str): Only "ema" or "sma". Default: "sma" - offset (int): How many periods to offset the result. Default: 0 + offset (int): How many periods to offset the result. Default: 0 Kwargs: tr (value, optional): Use True Range for Keltner Channels. Default: True diff --git a/pandas_ta/momentum/stoch.py b/pandas_ta/momentum/stoch.py index b08a84c..2b55b55 100644 --- a/pandas_ta/momentum/stoch.py +++ b/pandas_ta/momentum/stoch.py @@ -7,14 +7,17 @@ from pandas_ta.utils import get_offset, non_zero_range, verify_series def stoch(high, low, close, k=None, d=None, smooth_k=None, offset=None, **kwargs): """Indicator: Stochastic Oscillator (STOCH)""" # Validate arguments - high = verify_series(high) - low = verify_series(low) - close = verify_series(close) k = k if k and k > 0 else 14 d = d if d and d > 0 else 3 smooth_k = smooth_k if smooth_k and smooth_k > 0 else 3 + _length = max(k, d, smooth_k) + high = verify_series(high, _length) + low = verify_series(low, _length) + close = verify_series(close, _length) offset = get_offset(offset) + if high is None or low is None or close is None: return + # Calculate Result lowest_low = low.rolling(k).min() highest_high = high.rolling(k).max() @@ -88,7 +91,7 @@ Args: k (int): The Fast %K period. Default: 14 d (int): The Slow %K period. Default: 3 smooth_k (int): The Slow %D period. Default: 3 - offset (int): How many periods to offset the result. Default: 0 + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/momentum/stochrsi.py b/pandas_ta/momentum/stochrsi.py index 6fee6d4..cdd32b0 100644 --- a/pandas_ta/momentum/stochrsi.py +++ b/pandas_ta/momentum/stochrsi.py @@ -8,13 +8,15 @@ from pandas_ta.utils import get_offset, non_zero_range, verify_series def stochrsi(close, length=None, rsi_length=None, k=None, d=None, offset=None, **kwargs): """Indicator: Stochastic RSI Oscillator (STOCHRSI)""" # Validate arguments - close = verify_series(close) length = length if length and length > 0 else 14 rsi_length = rsi_length if rsi_length and rsi_length > 0 else 14 k = k if k and k > 0 else 3 d = d if d and d > 0 else 3 + close = verify_series(close, max(length, rsi_length, k, d)) offset = get_offset(offset) + if close is None: return + # Calculate Result rsi_ = rsi(close, length=rsi_length) lowest_rsi = rsi_.rolling(length).min() @@ -90,7 +92,7 @@ Args: rsi_length (int): RSI period. Default: 14 k (int): The Fast %K period. Default: 3 d (int): The Slow %K period. Default: 3 - offset (int): How many periods to offset the result. Default: 0 + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/momentum/td_seq.py b/pandas_ta/momentum/td_seq.py new file mode 100644 index 0000000..8bd12fd --- /dev/null +++ b/pandas_ta/momentum/td_seq.py @@ -0,0 +1,105 @@ +# -*- coding: utf-8 -*- +# import numpy as np +from numpy import where as npWhere +from pandas import DataFrame, Series +from pandas_ta.utils import get_offset, verify_series + + +def td_seq(close, asint=None, offset=None, **kwargs): + """Indicator: Tom Demark Sequential (TD_SEQ)""" + # Validate arguments + close = verify_series(close) + offset = get_offset(offset) + asint = asint if isinstance(asint, bool) else False + show_all = kwargs.setdefault("show_all", True) + + def true_sequence_count(series: Series): + index = series.where(series == False).last_valid_index() + + if index is None: + return series.count() + else: + s = series[series.index > index] + return s.count() + + def calc_td(series: Series, direction: str, show_all: bool): + td_bool = series.diff(4) > 0 if direction=="up" else series.diff(4) < 0 + td_num = npWhere( + td_bool, td_bool.rolling(13, min_periods=0).apply(true_sequence_count), 0 + ) + td_num = Series(td_num) + + if show_all: + td_num = td_num.mask(td_num == 0) + else: + td_num = td_num.mask(~td_num.between(6,9)) + + return td_num + + up_seq = calc_td(close, "up", show_all) + down_seq = calc_td(close, "down", show_all) + + if asint: + if up_seq.hasnans and down_seq.hasnans: + up_seq.fillna(0, inplace=True) + down_seq.fillna(0, inplace=True) + up_seq = up_seq.astype(int) + down_seq = down_seq.astype(int) + + # Offset + if offset != 0: + up_seq = up_seq.shift(offset) + down_seq = down_seq.shift(offset) + + # Handle fills + if "fillna" in kwargs: + up_seq.fillna(kwargs["fillna"], inplace=True) + down_seq.fillna(kwargs["fillna"], inplace=True) + + if "fill_method" in kwargs: + up_seq.fillna(method=kwargs["fill_method"], inplace=True) + down_seq.fillna(method=kwargs["fill_method"], inplace=True) + + # Name & Category + up_seq.name = f"TD_SEQ_UPa" if show_all else f"TD_SEQ_UP" + down_seq.name = f"TD_SEQ_DNa" if show_all else f"TD_SEQ_DN" + up_seq.category = down_seq.category = "momentum" + + # Prepare Dataframe to return + data = { + up_seq.name: up_seq, + down_seq.name: down_seq + } + df = DataFrame(data) + df.name = "TD_SEQ" + df.category = up_seq.category + + return df + + +td_seq.__doc__ = \ +"""TD Sequential (TD_SEQ) + +Tom DeMark's Sequential indicator attempts to identify a price point where an +uptrend or a downtrend exhausts itself and reverses. + +Sources: + https://tradetrekker.wordpress.com/tdsequential/ + +Calculation: + Compare current close price with 4 days ago price, up to 13 days. For the + consecutive ascending or descending price sequence, display 6th to 9th day + value. + +Args: + close (pd.Series): Series of 'close's + asint (bool): If True, fillnas with 0 and change type to int. Default: False + offset (int): How many periods to offset the result. Default: 0 + +Kwargs: + show_all (bool): Show 1 - 13. If set to False, show 6 - 9. Default: True + fillna (value, optional): pd.DataFrame.fillna(value) + +Returns: + pd.DataFrame: New feature generated. +""" \ No newline at end of file diff --git a/pandas_ta/momentum/trix.py b/pandas_ta/momentum/trix.py index 4745db0..3dad32e 100644 --- a/pandas_ta/momentum/trix.py +++ b/pandas_ta/momentum/trix.py @@ -7,13 +7,15 @@ from pandas_ta.utils import get_drift, get_offset, verify_series def trix(close, length=None, signal=None, scalar=None, drift=None, offset=None, **kwargs): """Indicator: Trix (TRIX)""" # Validate Arguments - close = verify_series(close) length = int(length) if length and length > 0 else 30 signal = int(signal) if signal and signal > 0 else 9 scalar = float(scalar) if scalar else 100 + close = verify_series(close, max(length, signal)) drift = get_drift(drift) offset = get_offset(offset) + if close is None: return + # Calculate Result ema1 = ema(close=close, length=length, **kwargs) ema2 = ema(close=ema1, length=length, **kwargs) @@ -68,11 +70,11 @@ Calculation: Args: close (pd.Series): Series of 'close's - length (int): It's period. Default: 18 - signal (int): It's period. Default: 9 - scalar (float): How much to magnify. Default: 100 - drift (int): The difference period. Default: 1 - offset (int): How many periods to offset the result. Default: 0 + length (int): It's period. Default: 18 + signal (int): It's period. Default: 9 + scalar (float): How much to magnify. Default: 100 + drift (int): The difference period. Default: 1 + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/momentum/tsi.py b/pandas_ta/momentum/tsi.py index 9f997a6..587e3eb 100644 --- a/pandas_ta/momentum/tsi.py +++ b/pandas_ta/momentum/tsi.py @@ -6,14 +6,17 @@ from pandas_ta.utils import get_drift, get_offset, verify_series def tsi(close, fast=None, slow=None, scalar=None, drift=None, offset=None, **kwargs): """Indicator: True Strength Index (TSI)""" # Validate Arguments - close = verify_series(close) fast = int(fast) if fast and fast > 0 else 13 slow = int(slow) if slow and slow > 0 else 25 # if slow < fast: # fast, slow = slow, fast scalar = float(scalar) if scalar else 100 + close = verify_series(close, max(fast, slow)) drift = get_drift(drift) offset = get_offset(offset) + if "length" in kwargs: kwargs.pop("length") + + if close is None: return # Calculate Result diff = close.diff(drift) @@ -73,7 +76,7 @@ Args: slow (int): The long period. Default: 25 scalar (float): How much to magnify. Default: 100 drift (int): The difference period. Default: 1 - offset (int): How many periods to offset the result. Default: 0 + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/momentum/uo.py b/pandas_ta/momentum/uo.py index 63640e4..2d0a784 100644 --- a/pandas_ta/momentum/uo.py +++ b/pandas_ta/momentum/uo.py @@ -6,20 +6,20 @@ from pandas_ta.utils import get_drift, get_offset, verify_series def uo(high, low, close, fast=None, medium=None, slow=None, fast_w=None, medium_w=None, slow_w=None, drift=None, offset=None, **kwargs): """Indicator: Ultimate Oscillator (UO)""" # Validate arguments - high = verify_series(high) - low = verify_series(low) - close = verify_series(close) + fast = int(fast) if fast and fast > 0 else 7 + fast_w = float(fast_w) if fast_w and fast_w > 0 else 4.0 + medium = int(medium) if medium and medium > 0 else 14 + medium_w = float(medium_w) if medium_w and medium_w > 0 else 2.0 + slow = int(slow) if slow and slow > 0 else 28 + slow_w = float(slow_w) if slow_w and slow_w > 0 else 1.0 + _length = max(fast, medium, slow) + high = verify_series(high, _length) + low = verify_series(low, _length) + close = verify_series(close, _length) drift = get_drift(drift) offset = get_offset(offset) - fast = int(fast) if fast and fast > 0 else 7 - fast_w = float(fast_w) if fast_w and fast_w > 0 else 4.0 - - medium = int(medium) if medium and medium > 0 else 14 - medium_w = float(medium_w) if medium_w and medium_w > 0 else 2.0 - - slow = int(slow) if slow and slow > 0 else 28 - slow_w = float(slow_w) if slow_w and slow_w > 0 else 1.0 + if high is None or low is None or close is None: return # Calculate Result tdf = DataFrame({ @@ -90,14 +90,14 @@ Args: high (pd.Series): Series of 'high's low (pd.Series): Series of 'low's close (pd.Series): Series of 'close's - fast (int): The Fast %K period. Default: 7 - medium (int): The Slow %K period. Default: 14 - slow (int): The Slow %D period. Default: 28 - fast_w (float): The Fast %K period. Default: 4.0 - medium_w (float): The Slow %K period. Default: 2.0 - slow_w (float): The Slow %D period. Default: 1.0 - drift (int): The difference period. Default: 1 - offset (int): How many periods to offset the result. Default: 0 + fast (int): The Fast %K period. Default: 7 + medium (int): The Slow %K period. Default: 14 + slow (int): The Slow %D period. Default: 28 + fast_w (float): The Fast %K period. Default: 4.0 + medium_w (float): The Slow %K period. Default: 2.0 + slow_w (float): The Slow %D period. Default: 1.0 + drift (int): The difference period. Default: 1 + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/momentum/willr.py b/pandas_ta/momentum/willr.py index f524aa6..8488ca5 100644 --- a/pandas_ta/momentum/willr.py +++ b/pandas_ta/momentum/willr.py @@ -1,17 +1,20 @@ # -*- coding: utf-8 -*- -from pandas_ta.utils import get_drift, get_offset, verify_series +from pandas_ta.utils import get_offset, verify_series def willr(high, low, close, length=None, offset=None, **kwargs): """Indicator: William's Percent R (WILLR)""" # Validate arguments - high = verify_series(high) - low = verify_series(low) - close = verify_series(close) length = int(length) if length and length > 0 else 14 min_periods = int(kwargs["min_periods"]) if "min_periods" in kwargs and kwargs["min_periods"] is not None else length + _length = max(length, min_periods) + high = verify_series(high, _length) + low = verify_series(low, _length) + close = verify_series(close, _length) offset = get_offset(offset) + if high is None or low is None or close is None: return + # Calculate Result lowest_low = low.rolling(length, min_periods=min_periods).min() highest_high = high.rolling(length, min_periods=min_periods).max() @@ -56,8 +59,8 @@ Args: high (pd.Series): Series of 'high's low (pd.Series): Series of 'low's close (pd.Series): Series of 'close's - length (int): It's period. Default: 14 - offset (int): How many periods to offset the result. Default: 0 + length (int): It's period. Default: 14 + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/overlap/__init__.py b/pandas_ta/overlap/__init__.py index 71725ae..d2022f3 100644 --- a/pandas_ta/overlap/__init__.py +++ b/pandas_ta/overlap/__init__.py @@ -1,4 +1,5 @@ # -*- coding: utf-8 -*- +from .alma import alma from .dema import dema from .ema import ema from .fwma import fwma @@ -6,6 +7,7 @@ from .hilo import hilo from .hl2 import hl2 from .hlc3 import hlc3 from .hma import hma +from .hwma import hwma from .kama import kama from .ichimoku import ichimoku from .linreg import linreg diff --git a/pandas_ta/overlap/alma.py b/pandas_ta/overlap/alma.py new file mode 100644 index 0000000..a98eed6 --- /dev/null +++ b/pandas_ta/overlap/alma.py @@ -0,0 +1,89 @@ +# -*- coding: utf-8 -*- +from numpy import exp as npExp +from numpy import NaN as npNaN +from pandas import Series +from pandas_ta.utils import get_offset, verify_series + + +def alma(close, length=None, sigma=None, distribution_offset=None, offset=None, **kwargs): + """Indicator: Arnaud Legoux Moving Average (ALMA)""" + # Validate Arguments + length = int(length) if length and length > 0 else 10 + sigma = float(sigma) if sigma and sigma > 0 else 6.0 + distribution_offset = float(distribution_offset) if distribution_offset and distribution_offset > 0 else 0.85 + close = verify_series(close, length) + offset = get_offset(offset) + + if close is None: return + + # Pre-Calculations + m = distribution_offset * (length - 1) + s = length / sigma + wtd = list(range(length)) + for i in range(0, length): + wtd[i] = npExp(-1 * ((i - m) * (i - m)) / (2 * s * s)) + + # Calculate Result + result = [npNaN for _ in range(0, length - 1)] + [0] + for i in range(length, close.size): + window_sum = 0 + cum_sum = 0 + for j in range(0, length): + # wtd = math.exp(-1 * ((j - m) * (j - m)) / (2 * s * s)) # moved to pre-calc for efficiency + window_sum = window_sum + wtd[j] * close.iloc[i - j] + cum_sum = cum_sum + wtd[j] + + almean = window_sum / cum_sum + result.append(npNaN) if i == length else result.append(almean) + + alma = Series(result, index=close.index) + + # Offset + if offset != 0: + alma = alma.shift(offset) + + # Handle fills + if "fillna" in kwargs: + alma.fillna(kwargs["fillna"], inplace=True) + if "fill_method" in kwargs: + alma.fillna(method=kwargs["fill_method"], inplace=True) + + # Name & Category + alma.name = f"ALMA_{length}_{sigma}_{distribution_offset}" + alma.category = "overlap" + + return alma + + +alma.__doc__ = \ +"""Arnaud Legoux Moving Average (ALMA) + +The ALMA moving average uses the curve of the Normal (Gauss) distribution, which +can be shifted from 0 to 1. This allows regulating the smoothness and high +sensitivity of the indicator. Sigma is another parameter that is responsible for +the shape of the curve coefficients. This moving average reduces lag of the data +in conjunction with smoothing to reduce noise. + +Implemented for Pandas TA by rengel8 based on the source provided below. + +Sources: + https://www.prorealcode.com/prorealtime-indicators/alma-arnaud-legoux-moving-average/ + +Calculation: + refer to provided source + +Args: + close (pd.Series): Series of 'close's + length (int): It's period, window size. Default: 10 + sigma (float): Smoothing value. Default 6.0 + distribution_offset (float): Value to offset the distribution min 0 + (smoother), max 1 (more responsive). Default 0.85 + offset (int): How many periods to offset the result. Default: 0 + +Kwargs: + fillna (value, optional): pd.DataFrame.fillna(value) + fill_method (value, optional): Type of fill method + +Returns: + pd.Series: New feature generated. +""" diff --git a/pandas_ta/overlap/dema.py b/pandas_ta/overlap/dema.py index 03e7ef1..afaf020 100644 --- a/pandas_ta/overlap/dema.py +++ b/pandas_ta/overlap/dema.py @@ -6,10 +6,12 @@ from pandas_ta.utils import get_offset, verify_series def dema(close, length=None, offset=None, **kwargs): """Indicator: Double Exponential Moving Average (DEMA)""" # Validate Arguments - close = verify_series(close) length = int(length) if length and length > 0 else 10 + close = verify_series(close, length) offset = get_offset(offset) + if close is None: return + # Calculate Result ema1 = ema(close=close, length=length) ema2 = ema(close=ema1, length=length) @@ -46,8 +48,8 @@ Calculation: Args: close (pd.Series): Series of 'close's - length (int): It's period. Default: 10 - offset (int): How many periods to offset the result. Default: 0 + length (int): It's period. Default: 10 + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/overlap/ema.py b/pandas_ta/overlap/ema.py index e3040a5..aa7721f 100644 --- a/pandas_ta/overlap/ema.py +++ b/pandas_ta/overlap/ema.py @@ -6,12 +6,14 @@ from pandas_ta.utils import get_offset, verify_series def ema(close, length=None, offset=None, **kwargs): """Indicator: Exponential Moving Average (EMA)""" # Validate Arguments - close = verify_series(close) length = int(length) if length and length > 0 else 10 adjust = kwargs.pop("adjust", False) sma = kwargs.pop("sma", True) + close = verify_series(close, length) offset = get_offset(offset) + if close is None: return + # Calculate Result if sma: close = close.copy() @@ -55,8 +57,8 @@ Calculation: Args: close (pd.Series): Series of 'close's - length (int): It's period. Default: 10 - offset (int): How many periods to offset the result. Default: 0 + length (int): It's period. Default: 10 + offset (int): How many periods to offset the result. Default: 0 Kwargs: adjust (bool, optional): Default: False diff --git a/pandas_ta/overlap/fwma.py b/pandas_ta/overlap/fwma.py index 8859217..1e060cc 100644 --- a/pandas_ta/overlap/fwma.py +++ b/pandas_ta/overlap/fwma.py @@ -5,11 +5,13 @@ from pandas_ta.utils import fibonacci, get_offset, verify_series, weights def fwma(close, length=None, asc=None, offset=None, **kwargs): """Indicator: Fibonacci's Weighted Moving Average (FWMA)""" # Validate Arguments - close = verify_series(close) length = int(length) if length and length > 0 else 10 asc = asc if asc else True + close = verify_series(close, length) offset = get_offset(offset) + if close is None: return + # Calculate Result fibs = fibonacci(n=length, weighted=True) fwma = close.rolling(length, min_periods=length).apply(weights(fibs), raw=True) @@ -47,9 +49,9 @@ Calculation: Args: close (pd.Series): Series of 'close's - length (int): It's period. Default: 10 - asc (bool): Recent values weigh more. Default: True - offset (int): How many periods to offset the result. Default: 0 + length (int): It's period. Default: 10 + asc (bool): Recent values weigh more. Default: True + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/overlap/hilo.py b/pandas_ta/overlap/hilo.py index 79016e6..bfd7471 100644 --- a/pandas_ta/overlap/hilo.py +++ b/pandas_ta/overlap/hilo.py @@ -1,7 +1,6 @@ # -*- coding: utf-8 -*- from numpy import NaN as npNaN from pandas import DataFrame, Series -# from pandas_ta.overlap.ma import ma from .ma import ma from pandas_ta.utils import get_offset, verify_series @@ -9,14 +8,17 @@ from pandas_ta.utils import get_offset, verify_series def hilo(high, low, close, high_length=None, low_length=None, mamode=None, offset=None, **kwargs): """Indicator: Gann HiLo (HiLo)""" # Validate Arguments - high = verify_series(high) - low = verify_series(low) - close = verify_series(close) high_length = int(high_length) if high_length and high_length > 0 else 13 low_length = int(low_length) if low_length and low_length > 0 else 21 mamode = mamode.lower() if isinstance(mamode, str) else "sma" + _length = max(high_length, low_length) + high = verify_series(high, _length) + low = verify_series(low, _length) + close = verify_series(close, _length) offset = get_offset(offset) + if high is None or low is None or close is None: return + # Calculate Result m = close.size hilo = Series(npNaN, index=close.index) @@ -113,8 +115,8 @@ Args: close (pd.Series): Series of 'close's high_length (int): It's period. Default: 13 low_length (int): It's period. Default: 21 - mamode (str): Options: 'sma' or 'ema'. Default: 'sma' - offset (int): How many periods to offset the result. Default: 0 + mamode (str): Options: 'sma' or 'ema'. Default: 'sma' + offset (int): How many periods to offset the result. Default: 0 Kwargs: adjust (bool): Default: True diff --git a/pandas_ta/overlap/hma.py b/pandas_ta/overlap/hma.py index 44a41d7..d6d55eb 100644 --- a/pandas_ta/overlap/hma.py +++ b/pandas_ta/overlap/hma.py @@ -1,5 +1,5 @@ # -*- coding: utf-8 -*- -from math import sqrt +from numpy import sqrt as npSqrt from .wma import wma from pandas_ta.utils import get_offset, verify_series @@ -7,13 +7,15 @@ from pandas_ta.utils import get_offset, verify_series def hma(close, length=None, offset=None, **kwargs): """Indicator: Hull Moving Average (HMA)""" # Validate Arguments - close = verify_series(close) length = int(length) if length and length > 0 else 10 + close = verify_series(close, length) offset = get_offset(offset) + if close is None: return + # Calculate Result half_length = int(length / 2) - sqrt_length = int(sqrt(length)) + sqrt_length = int(npSqrt(length)) wmaf = wma(close=close, length=half_length) wmas = wma(close=close, length=length) @@ -44,7 +46,7 @@ Calculation: length=10 WMA = Weighted Moving Average half_length = int(0.5 * length) - sqrt_length = int(math.sqrt(length)) + sqrt_length = int(sqrt(length)) wmaf = WMA(close, half_length) wmas = WMA(close, length) @@ -52,8 +54,8 @@ Calculation: Args: close (pd.Series): Series of 'close's - length (int): It's period. Default: 10 - offset (int): How many periods to offset the result. Default: 0 + length (int): It's period. Default: 10 + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/overlap/hwma.py b/pandas_ta/overlap/hwma.py new file mode 100644 index 0000000..e8eebd1 --- /dev/null +++ b/pandas_ta/overlap/hwma.py @@ -0,0 +1,82 @@ +# -*- coding: utf-8 -*- +from pandas import Series +from pandas_ta.utils import get_offset, verify_series + + +def hwma(close, na=None, nb=None, nc=None, offset=None, **kwargs): + """Indicator: Holt-Winter Moving Average""" + # Validate Arguments + na = float(na) if na and na > 0 and na < 1 else 0.2 + nb = float(nb) if nb and nb > 0 and nb < 1 else 0.1 + nc = float(nc) if nc and nc > 0 and nc < 1 else 0.1 + close = verify_series(close) + offset = get_offset(offset) + + # Calculate Result + last_a = last_v = 0 + last_f = close.iloc[0] + + result = [] + m = close.size + for i in range(m): + F = (1.0 - na) * (last_f + last_v + 0.5 * last_a) + na * close.iloc[i] + V = (1.0 - nb) * (last_v + last_a) + nb * (F - last_f) + A = (1.0 - nc) * last_a + nc * (V - last_v) + result.append((F + V + 0.5 * A)) + last_a, last_f, last_v = A, F, V # update values + + hwma = Series(result, index=close.index) + + # Offset + if offset != 0: + hwma = hwma.shift(offset) + + # Handle fills + if "fillna" in kwargs: + hwma.fillna(kwargs["fillna"], inplace=True) + if "fill_method" in kwargs: + hwma.fillna(method=kwargs["fill_method"], inplace=True) + + # Name & Category + suffix = f"{na}_{nb}_{nc}" + hwma.name = f"HWMA_{suffix}" + hwma.category = "overlap" + + return hwma + + + +hwma.__doc__ = \ +"""HWMA (Holt-Winter Moving Average) + +Indicator HWMA (Holt-Winter Moving Average) is a three-parameter moving average +by the Holt-Winter method; the three parameters should be selected to obtain a +forecast. + +This version has been implemented for Pandas TA by rengel8 based +on a publication for MetaTrader 5. + +Sources: + https://www.mql5.com/en/code/20856 + +Calculation: + HWMA[i] = F[i] + V[i] + 0.5 * A[i] + where.. + F[i] = (1-na) * (F[i-1] + V[i-1] + 0.5 * A[i-1]) + na * Price[i] + V[i] = (1-nb) * (V[i-1] + A[i-1]) + nb * (F[i] - F[i-1]) + A[i] = (1-nc) * A[i-1] + nc * (V[i] - V[i-1]) + +Args: + close (pd.Series): Series of 'close's + na (float): Smoothed series parameter (from 0 to 1). Default: 0.2 + nb (float): Trend parameter (from 0 to 1). Default: 0.1 + nc (float): Seasonality parameter (from 0 to 1). Default: 0.1 + close (pd.Series): Series of 'close's + +Kwargs: + fillna (value, optional): pd.DataFrame.fillna(value) + fill_method (value, optional): Type of fill method + +Returns: + pd.Series: hwma +""" diff --git a/pandas_ta/overlap/ichimoku.py b/pandas_ta/overlap/ichimoku.py index 537b536..2454741 100644 --- a/pandas_ta/overlap/ichimoku.py +++ b/pandas_ta/overlap/ichimoku.py @@ -6,14 +6,17 @@ from pandas_ta.utils import get_offset, verify_series def ichimoku(high, low, close, tenkan=None, kijun=None, senkou=None, offset=None, **kwargs): """Indicator: Ichimoku Kinkō Hyō (Ichimoku)""" - high = verify_series(high) - low = verify_series(low) - close = verify_series(close) tenkan = int(tenkan) if tenkan and tenkan > 0 else 9 kijun = int(kijun) if kijun and kijun > 0 else 26 senkou = int(senkou) if senkou and senkou > 0 else 52 + _length = max(tenkan, kijun, senkou) + high = verify_series(high, _length) + low = verify_series(low, _length) + close = verify_series(close, _length) offset = get_offset(offset) + if high is None or low is None or close is None: return None, None + # Calculate Result tenkan_sen = midprice(high=high, low=low, length=tenkan) kijun_sen = midprice(high=high, low=low, length=kijun) @@ -115,10 +118,10 @@ Args: high (pd.Series): Series of 'high's low (pd.Series): Series of 'low's close (pd.Series): Series of 'close's - tenkan (int): Tenkan period. Default: 9 - kijun (int): Kijun period. Default: 26 - senkou (int): Senkou period. Default: 52 - offset (int): How many periods to offset the result. Default: 0 + tenkan (int): Tenkan period. Default: 9 + kijun (int): Kijun period. Default: 26 + senkou (int): Senkou period. Default: 52 + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/overlap/kama.py b/pandas_ta/overlap/kama.py index 8adfbce..1c71266 100644 --- a/pandas_ta/overlap/kama.py +++ b/pandas_ta/overlap/kama.py @@ -1,22 +1,22 @@ # -*- coding: utf-8 -*- from numpy import NaN as npNaN -from pandas import Series, DataFrame +from pandas import Series from pandas_ta.utils import get_drift, get_offset, non_zero_range, verify_series def kama(close, length=None, fast=None, slow=None, drift=None, offset=None, **kwargs): - """Indicator: Kaufman's Adaptive Moving Average (HMA)""" + """Indicator: Kaufman's Adaptive Moving Average (KAMA)""" # Validate Arguments - close = verify_series(close) length = int(length) if length and length > 0 else 10 fast = int(fast) if fast and fast > 0 else 2 slow = int(slow) if slow and slow > 0 else 30 + close = verify_series(close, max(fast, slow, length)) drift = get_drift(drift) offset = get_offset(offset) - # Calculate Result - m = close.size + if close is None: return + # Calculate Result def weight(length: int) -> float: return 2 / (length + 1) @@ -30,9 +30,10 @@ def kama(close, length=None, fast=None, slow=None, drift=None, offset=None, **kw x = er * (fr - sr) + sr sc = x * x + m = close.size result = [npNaN for _ in range(0, length - 1)] + [0] for i in range(length, m): - result.append(sc[i] * close[i] + (1 - sc[i]) * result[i - 1]) + result.append(sc.iloc[i] * close.iloc[i] + (1 - sc.iloc[i]) * result[i - 1]) kama = Series(result, index=close.index) @@ -66,11 +67,11 @@ Calculation: Args: close (pd.Series): Series of 'close's - length (int): It's period. Default: 10 - fast (int): Fast MA period. Default: 2 - slow (int): Slow MA period. Default: 30 - drift (int): The difference period. Default: 1 - offset (int): How many periods to offset the result. Default: 0 + length (int): It's period. Default: 10 + fast (int): Fast MA period. Default: 2 + slow (int): Slow MA period. Default: 30 + drift (int): The difference period. Default: 1 + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/overlap/linreg.py b/pandas_ta/overlap/linreg.py index aa35cb9..5d1cbb3 100644 --- a/pandas_ta/overlap/linreg.py +++ b/pandas_ta/overlap/linreg.py @@ -1,13 +1,15 @@ # -*- coding: utf-8 -*- -import math +from numpy import arctan as npAtan +from numpy import pi as npPi +from numpy import sqrt as npSqrt from pandas_ta.utils import get_offset, verify_series def linreg(close, length=None, offset=None, **kwargs): """Indicator: Linear Regression""" # Validate arguments - close = verify_series(close) length = int(length) if length and length > 0 else 14 + close = verify_series(close, length) offset = get_offset(offset) angle = kwargs.pop("angle", False) intercept = kwargs.pop("intercept", False) @@ -16,6 +18,8 @@ def linreg(close, length=None, offset=None, **kwargs): slope = kwargs.pop("slope", False) tsf = kwargs.pop("tsf", False) + if close is None: return + # Calculate Result x = range(1, length + 1) # [1, 2, ..., n] from 1 to n keeps Sum(xy) low x_sum = 0.5 * length * (length + 1) @@ -34,15 +38,15 @@ def linreg(close, length=None, offset=None, **kwargs): return b if angle: - theta = math.atan(m) + theta = npAtan(m) if degrees: - theta *= 180 / math.pi + theta *= 180 / npPi return theta if r: y2_sum = (series * series).sum() rn = length * xy_sum - x_sum * y_sum - rd = math.sqrt(divisor * (length * y2_sum - y_sum * y_sum)) + rd = npSqrt(divisor * (length * y2_sum - y_sum * y_sum)) return rn / rd return m * length + b if tsf else m * (length - 1) + b @@ -105,12 +109,16 @@ Args: offset (int): How many periods to offset the result. Default: 0 Kwargs: - angle (bool, optional): If True, returns the angle of the slope in radians. Default: False. - degrees (bool, optional): If True, returns the angle of the slope in degrees. Default: False. - intercept (bool, optional): If True, returns the angle of the slope in radians. Default: False. - r (bool, optional): If True, returns it's correlation 'r'. Default: False. + angle (bool, optional): If True, returns the angle of the slope in radians. + Default: False. + degrees (bool, optional): If True, returns the angle of the slope in + degrees. Default: False. + intercept (bool, optional): If True, returns the angle of the slope in + radians. Default: False. + r (bool, optional): If True, returns it's correlation 'r'. Default: False. slope (bool, optional): If True, returns the slope. Default: False. - tsf (bool, optional): If True, returns the Time Series Forecast value. Default: False. + tsf (bool, optional): If True, returns the Time Series Forecast value. + Default: False. fillna (value, optional): pd.DataFrame.fillna(value) fill_method (value, optional): Type of fill method diff --git a/pandas_ta/overlap/mcgd.py b/pandas_ta/overlap/mcgd.py index f353c8c..f2bd86c 100644 --- a/pandas_ta/overlap/mcgd.py +++ b/pandas_ta/overlap/mcgd.py @@ -5,11 +5,13 @@ from pandas_ta.utils import get_offset, verify_series def mcgd(close, length=None, offset=None, c=None, **kwargs): """Indicator: McGinley Dynamic Indicator""" # Validate arguments - close = verify_series(close) length = int(length) if length and length > 0 else 10 c = float(c) if c and 0 < c <= 1 else 1 + close = verify_series(close, length) offset = get_offset(offset) + if close is None: return + # Calculate Result close = close.copy() diff --git a/pandas_ta/overlap/midpoint.py b/pandas_ta/overlap/midpoint.py index f845e2e..60a8671 100644 --- a/pandas_ta/overlap/midpoint.py +++ b/pandas_ta/overlap/midpoint.py @@ -5,11 +5,13 @@ from pandas_ta.utils import get_offset, verify_series def midpoint(close, length=None, offset=None, **kwargs): """Indicator: Midpoint""" # Validate arguments - close = verify_series(close) length = int(length) if length and length > 0 else 2 min_periods = int(kwargs["min_periods"]) if "min_periods" in kwargs and kwargs["min_periods"] is not None else length + close = verify_series(close, max(length, min_periods)) offset = get_offset(offset) + if close is None: return + # Calculate Result lowest = close.rolling(length, min_periods=min_periods).min() highest = close.rolling(length, min_periods=min_periods).max() diff --git a/pandas_ta/overlap/midprice.py b/pandas_ta/overlap/midprice.py index cf9a693..646ce45 100644 --- a/pandas_ta/overlap/midprice.py +++ b/pandas_ta/overlap/midprice.py @@ -5,12 +5,15 @@ from pandas_ta.utils import get_offset, verify_series def midprice(high, low, length=None, offset=None, **kwargs): """Indicator: Midprice""" # Validate arguments - high = verify_series(high) - low = verify_series(low) length = int(length) if length and length > 0 else 2 min_periods = int(kwargs["min_periods"]) if "min_periods" in kwargs and kwargs["min_periods"] is not None else length + _length = max(length, min_periods) + high = verify_series(high, _length) + low = verify_series(low, _length) offset = get_offset(offset) + if high is None or low is None: return + # Calculate Result lowest_low = low.rolling(length, min_periods=min_periods).min() highest_high = high.rolling(length, min_periods=min_periods).max() diff --git a/pandas_ta/overlap/pwma.py b/pandas_ta/overlap/pwma.py index 61c91a9..f3867d1 100644 --- a/pandas_ta/overlap/pwma.py +++ b/pandas_ta/overlap/pwma.py @@ -5,12 +5,13 @@ from pandas_ta.utils import get_offset, pascals_triangle, verify_series, weights def pwma(close, length=None, asc=None, offset=None, **kwargs): """Indicator: Pascals Weighted Moving Average (PWMA)""" # Validate Arguments - close = verify_series(close) length = int(length) if length and length > 0 else 10 - min_periods = int(kwargs["min_periods"]) if "min_periods" in kwargs and kwargs["min_periods"] is not None else length asc = asc if asc else True + close = verify_series(close, length) offset = get_offset(offset) + if close is None: return + # Calculate Result triangle = pascals_triangle(n=length - 1, weighted=True) pwma = close.rolling(length, min_periods=length).apply(weights(triangle), raw=True) @@ -29,8 +30,8 @@ def pwma(close, length=None, asc=None, offset=None, **kwargs): pwma.__doc__ = \ """Pascal's Weighted Moving Average (PWMA) -Pascal's Weighted Moving Average is similar to a symmetric triangular -window except PWMA's weights are based on Pascal's Triangle. +Pascal's Weighted Moving Average is similar to a symmetric triangular window +except PWMA's weights are based on Pascal's Triangle. Source: Kevin Johnson @@ -49,8 +50,8 @@ Calculation: Args: close (pd.Series): Series of 'close's length (int): It's period. Default: 10 - asc (bool): Recent values weigh more. Default: True - offset (int): How many periods to offset the result. Default: 0 + asc (bool): Recent values weigh more. Default: True + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/overlap/rma.py b/pandas_ta/overlap/rma.py index cc122e0..41d1845 100644 --- a/pandas_ta/overlap/rma.py +++ b/pandas_ta/overlap/rma.py @@ -5,10 +5,12 @@ from pandas_ta.utils import get_offset, verify_series def rma(close, length=None, offset=None, **kwargs): """Indicator: wildeR's Moving Average (RMA)""" # Validate Arguments - close = verify_series(close) length = int(length) if length and length > 0 else 10 - offset = get_offset(offset) alpha = (1.0 / length) if length > 0 else 0.5 + close = verify_series(close, length) + offset = get_offset(offset) + + if close is None: return # Calculate Result rma = close.ewm(alpha=alpha, min_periods=length).mean() @@ -27,7 +29,8 @@ def rma(close, length=None, offset=None, **kwargs): rma.__doc__ = \ """wildeR's Moving Average (RMA) -The WildeR's Moving Average is simply an Exponential Moving Average (EMA) with a modified alpha = 1 / length. +The WildeR's Moving Average is simply an Exponential Moving Average (EMA) with +a modified alpha = 1 / length. Sources: https://tlc.thinkorswim.com/center/reference/Tech-Indicators/studies-library/V-Z/WildersSmoothing @@ -42,8 +45,8 @@ Calculation: Args: close (pd.Series): Series of 'close's - length (int): It's period. Default: 10 - offset (int): How many periods to offset the result. Default: 0 + length (int): It's period. Default: 10 + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/overlap/sinwma.py b/pandas_ta/overlap/sinwma.py index 37f1c98..44d05ca 100644 --- a/pandas_ta/overlap/sinwma.py +++ b/pandas_ta/overlap/sinwma.py @@ -1,6 +1,6 @@ # -*- coding: utf-8 -*- -from math import pi -from math import sin +from numpy import pi as npPi +from numpy import sin as npSin from pandas import Series from pandas_ta.utils import get_offset, verify_series, weights @@ -8,12 +8,14 @@ from pandas_ta.utils import get_offset, verify_series, weights def sinwma(close, length=None, offset=None, **kwargs): """Indicator: Sine Weighted Moving Average (SINWMA) by Everget of TradingView""" # Validate Arguments - close = verify_series(close) length = int(length) if length and length > 0 else 14 + close = verify_series(close, length) offset = get_offset(offset) + if close is None: return + # Calculate Result - sines = Series([sin((i + 1) * pi / (length + 1)) for i in range(0, length)]) + sines = Series([npSin((i + 1) * npPi / (length + 1)) for i in range(0, length)]) w = sines / sines.sum() sinwma = close.rolling(length, min_periods=length).apply(weights(w), raw=True) @@ -32,8 +34,8 @@ def sinwma(close, length=None, offset=None, **kwargs): sinwma.__doc__ = \ """Sine Weighted Moving Average (SWMA) -A weighted average using sine cycles. The middle term(s) of the average have the highest -weight(s). +A weighted average using sine cycles. The middle term(s) of the average have the +highest weight(s). Source: https://www.tradingview.com/script/6MWFvnPO-Sine-Weighted-Moving-Average/ @@ -54,8 +56,8 @@ Calculation: Args: close (pd.Series): Series of 'close's - length (int): It's period. Default: 10 - offset (int): How many periods to offset the result. Default: 0 + length (int): It's period. Default: 10 + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/overlap/sma.py b/pandas_ta/overlap/sma.py index b196f7e..9ece7f1 100644 --- a/pandas_ta/overlap/sma.py +++ b/pandas_ta/overlap/sma.py @@ -5,11 +5,13 @@ from pandas_ta.utils import get_offset, verify_series def sma(close, length=None, offset=None, **kwargs): """Indicator: Simple Moving Average (SMA)""" # Validate Arguments - close = verify_series(close) length = int(length) if length and length > 0 else 10 min_periods = int(kwargs["min_periods"]) if "min_periods" in kwargs and kwargs["min_periods"] is not None else length + close = verify_series(close, max(length, min_periods)) offset = get_offset(offset) + if close is None: return + # Calculate Result sma = close.rolling(length, min_periods=min_periods).mean() @@ -46,8 +48,8 @@ Calculation: Args: close (pd.Series): Series of 'close's - length (int): It's period. Default: 10 - offset (int): How many periods to offset the result. Default: 0 + length (int): It's period. Default: 10 + offset (int): How many periods to offset the result. Default: 0 Kwargs: adjust (bool): Default: True diff --git a/pandas_ta/overlap/ssf.py b/pandas_ta/overlap/ssf.py index ae9e2ce..04c7a61 100644 --- a/pandas_ta/overlap/ssf.py +++ b/pandas_ta/overlap/ssf.py @@ -3,18 +3,19 @@ from numpy import cos as npCos from numpy import exp as npExp from numpy import pi as npPi from numpy import sqrt as npSqrt -from pandas import Series from pandas_ta.utils import get_offset, verify_series def ssf(close, length=None, poles=None, offset=None, **kwargs): """Indicator: Ehler's Super Smoother Filter (SSF)""" # Validate Arguments - close = verify_series(close) length = int(length) if length and length > 0 else 10 poles = int(poles) if poles in [2, 3] else 2 + close = verify_series(close, length) offset = get_offset(offset) + if close is None: return + # Calculate Result m = close.size ssf = close.copy() diff --git a/pandas_ta/overlap/supertrend.py b/pandas_ta/overlap/supertrend.py index d53653d..5fd0f47 100644 --- a/pandas_ta/overlap/supertrend.py +++ b/pandas_ta/overlap/supertrend.py @@ -9,13 +9,15 @@ from pandas_ta.utils import get_offset, verify_series def supertrend(high, low, close, length=None, multiplier=None, offset=None, **kwargs): """Indicator: Supertrend""" # Validate Arguments - high = verify_series(high) - low = verify_series(low) - close = verify_series(close) length = int(length) if length and length > 0 else 7 multiplier = float(multiplier) if multiplier and multiplier > 0 else 3.0 + high = verify_series(high, length) + low = verify_series(low, length) + close = verify_series(close, length) offset = get_offset(offset) + if high is None or low is None or close is None: return + # Calculate Results m = close.size dir_, trend = [1] * m, [0] * m @@ -109,8 +111,9 @@ Args: low (pd.Series): Series of 'low's close (pd.Series): Series of 'close's length (int) : length for ATR calculation. Default: 7 - multiplier (float): Coefficient for upper and lower band distance to midrange. Default: 3.0 - offset (int): How many periods to offset the result. Default: 0 + multiplier (float): Coefficient for upper and lower band distance to + midrange. Default: 3.0 + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/overlap/swma.py b/pandas_ta/overlap/swma.py index 229c2fc..7eedea5 100644 --- a/pandas_ta/overlap/swma.py +++ b/pandas_ta/overlap/swma.py @@ -5,15 +5,18 @@ from pandas_ta.utils import get_offset, symmetric_triangle, verify_series, weigh def swma(close, length=None, asc=None, offset=None, **kwargs): """Indicator: Symmetric Weighted Moving Average (SWMA)""" # Validate Arguments - close = verify_series(close) length = int(length) if length and length > 0 else 10 - min_periods = int(kwargs["min_periods"]) if "min_periods" in kwargs and kwargs["min_periods"] is not None else length + # min_periods = int(kwargs["min_periods"]) if "min_periods" in kwargs and kwargs["min_periods"] is not None else length asc = asc if asc else True + close = verify_series(close, length) offset = get_offset(offset) + if close is None: return + # Calculate Result triangle = symmetric_triangle(length, weighted=True) swma = close.rolling(length, min_periods=length).apply(weights(triangle), raw=True) + # swma = close.rolling(length).apply(weights(triangle), raw=True) # Offset if offset != 0: @@ -30,8 +33,9 @@ swma.__doc__ = \ """Symmetric Weighted Moving Average (SWMA) Symmetric Weighted Moving Average where weights are based on a symmetric -triangle. For example: n=3 -> [1, 2, 1], n=4 -> [1, 2, 2, 1], etc... This moving -average has variable length in contrast to TradingView's fixed length of 4. +triangle. For example: n=3 -> [1, 2, 1], n=4 -> [1, 2, 2, 1], etc... +This moving average has variable length in contrast to TradingView's fixed +length of 4. Source: https://www.tradingview.com/study-script-reference/#fun_swma @@ -50,9 +54,9 @@ Calculation: Args: close (pd.Series): Series of 'close's - length (int): It's period. Default: 10 - asc (bool): Recent values weigh more. Default: True - offset (int): How many periods to offset the result. Default: 0 + length (int): It's period. Default: 10 + asc (bool): Recent values weigh more. Default: True + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/overlap/t3.py b/pandas_ta/overlap/t3.py index 386abc2..d8b5663 100644 --- a/pandas_ta/overlap/t3.py +++ b/pandas_ta/overlap/t3.py @@ -6,11 +6,13 @@ from pandas_ta.utils import get_offset, verify_series def t3(close, length=None, a=None, offset=None, **kwargs): """Indicator: T3""" # Validate Arguments - close = verify_series(close) length = int(length) if length and length > 0 else 10 a = float(a) if a and a > 0 and a < 1 else 0.7 + close = verify_series(close, length) offset = get_offset(offset) + if close is None: return + # Calculate Result c1 = -a * a**2 c2 = 3 * a**2 + 3 * a**3 @@ -62,9 +64,9 @@ Calculation: Args: close (pd.Series): Series of 'close's - length (int): It's period. Default: 10 - a (float): 0 < a < 1. Default: 0.7 - offset (int): How many periods to offset the result. Default: 0 + length (int): It's period. Default: 10 + a (float): 0 < a < 1. Default: 0.7 + offset (int): How many periods to offset the result. Default: 0 Kwargs: adjust (bool): Default: True diff --git a/pandas_ta/overlap/tema.py b/pandas_ta/overlap/tema.py index cfd3e10..19afe54 100644 --- a/pandas_ta/overlap/tema.py +++ b/pandas_ta/overlap/tema.py @@ -6,10 +6,12 @@ from pandas_ta.utils import get_offset, verify_series def tema(close, length=None, offset=None, **kwargs): """Indicator: Triple Exponential Moving Average (TEMA)""" # Validate Arguments - close = verify_series(close) length = int(length) if length and length > 0 else 10 + close = verify_series(close, length) offset = get_offset(offset) + if close is None: return + # Calculate Result ema1 = ema(close=close, length=length, **kwargs) ema2 = ema(close=ema1, length=length, **kwargs) @@ -46,8 +48,8 @@ Calculation: Args: close (pd.Series): Series of 'close's - length (int): It's period. Default: 10 - offset (int): How many periods to offset the result. Default: 0 + length (int): It's period. Default: 10 + offset (int): How many periods to offset the result. Default: 0 Kwargs: adjust (bool): Default: True diff --git a/pandas_ta/overlap/trima.py b/pandas_ta/overlap/trima.py index 0a06dc0..151672b 100644 --- a/pandas_ta/overlap/trima.py +++ b/pandas_ta/overlap/trima.py @@ -6,10 +6,12 @@ from pandas_ta.utils import get_offset, verify_series def trima(close, length=None, offset=None, **kwargs): """Indicator: Triangular Moving Average (TRIMA)""" # Validate Arguments - close = verify_series(close) length = int(length) if length and length > 0 else 10 + close = verify_series(close, length) offset = get_offset(offset) + if close is None: return + # Calculate Result half_length = round(0.5 * (length + 1)) sma1 = sma(close, length=half_length) @@ -41,14 +43,14 @@ Calculation: Default Inputs: length=10 SMA = Simple Moving Average - half_length = math.round(0.5 * (length + 1)) + half_length = round(0.5 * (length + 1)) SMA1 = SMA(close, half_length) TRIMA = SMA(SMA1, half_length) Args: close (pd.Series): Series of 'close's - length (int): It's period. Default: 10 - offset (int): How many periods to offset the result. Default: 0 + length (int): It's period. Default: 10 + offset (int): How many periods to offset the result. Default: 0 Kwargs: adjust (bool): Default: True diff --git a/pandas_ta/overlap/vidya.py b/pandas_ta/overlap/vidya.py index ab82f8d..939654f 100644 --- a/pandas_ta/overlap/vidya.py +++ b/pandas_ta/overlap/vidya.py @@ -7,11 +7,13 @@ from pandas_ta.utils import get_drift, get_offset, verify_series def vidya(close, length=None, drift=None, offset=None, **kwargs): """Indicator: Variable Index Dynamic Average (VIDYA)""" # Validate Arguments - close = verify_series(close) length = int(length) if length and length > 0 else 14 + close = verify_series(close, length) drift = get_drift(drift) offset = get_offset(offset) + if close is None: return + def _cmo(source: Series, n:int , d: int): """Chande Momentum Oscillator (CMO) Patch For some reason: from pandas_ta.momentum import cmo causes diff --git a/pandas_ta/overlap/vwma.py b/pandas_ta/overlap/vwma.py index 78b376e..a77cd74 100644 --- a/pandas_ta/overlap/vwma.py +++ b/pandas_ta/overlap/vwma.py @@ -6,11 +6,13 @@ from pandas_ta.utils import get_offset, verify_series def vwma(close, volume, length=None, offset=None, **kwargs): """Indicator: Volume Weighted Moving Average (VWMA)""" # Validate Arguments - close = verify_series(close) - volume = verify_series(volume) length = int(length) if length and length > 0 else 10 + close = verify_series(close, length) + volume = verify_series(volume, length) offset = get_offset(offset) + if close is None or volume is None: return + # Calculate Result pv = close * volume vwma = sma(close=pv, length=length) / sma(close=volume, length=length) @@ -44,8 +46,8 @@ Calculation: Args: close (pd.Series): Series of 'close's volume (pd.Series): Series of 'volume's - length (int): It's period. Default: 10 - offset (int): How many periods to offset the result. Default: 0 + length (int): It's period. Default: 10 + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/overlap/wcp.py b/pandas_ta/overlap/wcp.py index 4bf71e8..90b13c9 100644 --- a/pandas_ta/overlap/wcp.py +++ b/pandas_ta/overlap/wcp.py @@ -40,7 +40,7 @@ Args: high (pd.Series): Series of 'high's low (pd.Series): Series of 'low's close (pd.Series): Series of 'close's - offset (int): How many periods to offset the result. Default: 0 + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/overlap/wma.py b/pandas_ta/overlap/wma.py index 9c554ba..4e4b9b0 100644 --- a/pandas_ta/overlap/wma.py +++ b/pandas_ta/overlap/wma.py @@ -8,11 +8,13 @@ from pandas_ta.utils import get_offset, verify_series def wma(close, length=None, asc=None, offset=None, **kwargs): """Indicator: Weighted Moving Average (WMA)""" # Validate Arguments - close = verify_series(close) length = int(length) if length and length > 0 else 10 asc = asc if asc else True + close = verify_series(close, length) offset = get_offset(offset) + if close is None: return + # Calculate Result total_weight = 0.5 * length * (length + 1) weights_ = Series(npArange(1, length + 1)) @@ -62,9 +64,9 @@ Calculation: Args: close (pd.Series): Series of 'close's - length (int): It's period. Default: 10 - asc (bool): Recent values weigh more. Default: True - offset (int): How many periods to offset the result. Default: 0 + length (int): It's period. Default: 10 + asc (bool): Recent values weigh more. Default: True + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/overlap/zlma.py b/pandas_ta/overlap/zlma.py index 11e6eb1..0dabfeb 100644 --- a/pandas_ta/overlap/zlma.py +++ b/pandas_ta/overlap/zlma.py @@ -8,10 +8,12 @@ from pandas_ta.utils import get_offset, verify_series def zlma(close, length=None, mamode=None, offset=None, **kwargs): """Indicator: Zero Lag Moving Average (ZLMA)""" # Validate Arguments - close = verify_series(close) length = int(length) if length and length > 0 else 10 - offset = get_offset(offset) mamode = mamode.lower() if isinstance(mamode, str) else "ema" + close = verify_series(close, length) + offset = get_offset(offset) + + if close is None: return # Calculate Result lag = int(0.5 * (length - 1)) @@ -60,9 +62,9 @@ Calculation: Args: close (pd.Series): Series of 'close's - length (int): It's period. Default: 10 - mamode (str): Options: 'ema', 'hma', 'sma', 'wma'. Default: 'ema' - offset (int): How many periods to offset the result. Default: 0 + length (int): It's period. Default: 10 + mamode (str): Options: 'ema', 'hma', 'sma', 'wma'. Default: 'ema' + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/performance/log_return.py b/pandas_ta/performance/log_return.py index f716a63..8e73d84 100644 --- a/pandas_ta/performance/log_return.py +++ b/pandas_ta/performance/log_return.py @@ -6,10 +6,12 @@ from pandas_ta.utils import get_offset, verify_series def log_return(close, length=None, cumulative=False, offset=None, **kwargs): """Indicator: Log Return""" # Validate Arguments - close = verify_series(close) length = int(length) if length and length > 0 else 1 + close = verify_series(close, length) offset = get_offset(offset) + if close is None: return + # Calculate Result log_return = nplog(close).diff(periods=length) @@ -50,9 +52,9 @@ Calculation: Args: close (pd.Series): Series of 'close's - length (int): It's period. Default: 20 - cumulative (bool): If True, returns the cumulative returns. Default: False - offset (int): How many periods to offset the result. Default: 0 + length (int): It's period. Default: 20 + cumulative (bool): If True, returns the cumulative returns. Default: False + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/performance/percent_return.py b/pandas_ta/performance/percent_return.py index 2c97083..d045a79 100644 --- a/pandas_ta/performance/percent_return.py +++ b/pandas_ta/performance/percent_return.py @@ -5,10 +5,12 @@ from pandas_ta.utils import get_offset, verify_series def percent_return(close, length=None, cumulative=False, offset=None, **kwargs): """Indicator: Percent Return""" # Validate Arguments - close = verify_series(close) length = int(length) if length and length > 0 else 1 + close = verify_series(close, length) offset = get_offset(offset) + if close is None: return + # Calculate Result pct_return = close.pct_change(length) @@ -43,9 +45,9 @@ Calculation: Args: close (pd.Series): Series of 'close's - length (int): It's period. Default: 20 - cumulative (bool): If True, returns the cumulative returns. Default: False - offset (int): How many periods to offset the result. Default: 0 + length (int): It's period. Default: 20 + cumulative (bool): If True, returns the cumulative returns. Default: False + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/performance/trend_return.py b/pandas_ta/performance/trend_return.py index 1116b33..b122d6a 100644 --- a/pandas_ta/performance/trend_return.py +++ b/pandas_ta/performance/trend_return.py @@ -1,5 +1,5 @@ # -*- coding: utf-8 -*- -from pandas import DataFrame, Series +from pandas import DataFrame from .log_return import log_return from .percent_return import percent_return from pandas_ta.utils import get_offset, verify_series, zero @@ -12,7 +12,8 @@ def trend_return(close, trend, log=True, cumulative=None, trend_reset=0, trade_o trend = verify_series(trend) cumulative = cumulative if cumulative is not None and isinstance(cumulative, bool) else False trend_reset = int(trend_reset) if trend_reset and isinstance(trend_reset, int) else 0 - trade_offset = int(trade_offset) if trade_offset and isinstance(trade_offset, int) else -1 + if trade_offset !=0: + trade_offset = int(trade_offset) if trade_offset and isinstance(trade_offset, int) else -1 offset = get_offset(offset) # Calculate Result diff --git a/pandas_ta/statistics/entropy.py b/pandas_ta/statistics/entropy.py index c3e05ef..175bda2 100644 --- a/pandas_ta/statistics/entropy.py +++ b/pandas_ta/statistics/entropy.py @@ -6,11 +6,13 @@ from pandas_ta.utils import get_offset, verify_series def entropy(close, length=None, base=None, offset=None, **kwargs): """Indicator: Entropy (ENTP)""" # Validate Arguments - close = verify_series(close) length = int(length) if length and length > 0 else 10 base = float(base) if base and base > 0 else 2.0 + close = verify_series(close, length) offset = get_offset(offset) + if close is None: return + # Calculate Result p = close / close.rolling(length).sum() entropy = (-p * npLog(p) / npLog(base)).rolling(length).sum() diff --git a/pandas_ta/statistics/kurtosis.py b/pandas_ta/statistics/kurtosis.py index 8b477f2..6db14ba 100644 --- a/pandas_ta/statistics/kurtosis.py +++ b/pandas_ta/statistics/kurtosis.py @@ -5,11 +5,13 @@ from pandas_ta.utils import get_offset, verify_series def kurtosis(close, length=None, offset=None, **kwargs): """Indicator: Kurtosis""" # Validate Arguments - close = verify_series(close) length = int(length) if length and length > 0 else 30 min_periods = int(kwargs["min_periods"]) if "min_periods" in kwargs and kwargs["min_periods"] is not None else length + close = verify_series(close, max(length, min_periods)) offset = get_offset(offset) + if close is None: return + # Calculate Result kurtosis = close.rolling(length, min_periods=min_periods).kurt() diff --git a/pandas_ta/statistics/mad.py b/pandas_ta/statistics/mad.py index 8d813af..3319dd7 100644 --- a/pandas_ta/statistics/mad.py +++ b/pandas_ta/statistics/mad.py @@ -6,11 +6,13 @@ from pandas_ta.utils import get_offset, verify_series def mad(close, length=None, offset=None, **kwargs): """Indicator: Mean Absolute Deviation""" # Validate Arguments - close = verify_series(close) length = int(length) if length and length > 0 else 30 min_periods = int(kwargs["min_periods"]) if "min_periods" in kwargs and kwargs["min_periods"] is not None else length + close = verify_series(close, max(length, min_periods)) offset = get_offset(offset) + if close is None: return + # Calculate Result def mad_(series): """Mean Absolute Deviation""" diff --git a/pandas_ta/statistics/median.py b/pandas_ta/statistics/median.py index 023dbcb..d7bf291 100644 --- a/pandas_ta/statistics/median.py +++ b/pandas_ta/statistics/median.py @@ -5,11 +5,13 @@ from pandas_ta.utils import get_offset, verify_series def median(close, length=None, offset=None, **kwargs): """Indicator: Median""" # Validate Arguments - close = verify_series(close) length = int(length) if length and length > 0 else 30 min_periods = int(kwargs["min_periods"]) if "min_periods" in kwargs and kwargs["min_periods"] is not None else length + close = verify_series(close, max(length, min_periods)) offset = get_offset(offset) + if close is None: return + # Calculate Result median = close.rolling(length, min_periods=min_periods).median() @@ -27,7 +29,7 @@ def median(close, length=None, offset=None, **kwargs): median.__doc__ = \ """Rolling Median -Rolling Median of over 'n' periods. Sibling of a Simple Moving Average. +Rolling Median of over 'n' periods. Sibling of a Simple Moving Average. Sources: https://www.incrediblecharts.com/indicators/median_price.php diff --git a/pandas_ta/statistics/quantile.py b/pandas_ta/statistics/quantile.py index 543c972..531a0df 100644 --- a/pandas_ta/statistics/quantile.py +++ b/pandas_ta/statistics/quantile.py @@ -5,12 +5,14 @@ from pandas_ta.utils import get_offset, verify_series def quantile(close, length=None, q=None, offset=None, **kwargs): """Indicator: Quantile""" # Validate Arguments - close = verify_series(close) length = int(length) if length and length > 0 else 30 min_periods = int(kwargs["min_periods"]) if "min_periods" in kwargs and kwargs["min_periods"] is not None else length q = float(q) if q and q > 0 and q < 1 else 0.5 + close = verify_series(close, max(length, min_periods)) offset = get_offset(offset) + if close is None: return + # Calculate Result quantile = close.rolling(length, min_periods=min_periods).quantile(q) diff --git a/pandas_ta/statistics/skew.py b/pandas_ta/statistics/skew.py index 560bbd4..79d0212 100644 --- a/pandas_ta/statistics/skew.py +++ b/pandas_ta/statistics/skew.py @@ -5,11 +5,13 @@ from pandas_ta.utils import get_offset, verify_series def skew(close, length=None, offset=None, **kwargs): """Indicator: Skew""" # Validate Arguments - close = verify_series(close) length = int(length) if length and length > 0 else 30 min_periods = int(kwargs["min_periods"]) if "min_periods" in kwargs and kwargs["min_periods"] is not None else length + close = verify_series(close, max(length, min_periods)) offset = get_offset(offset) + if close is None: return + # Calculate Result skew = close.rolling(length, min_periods=min_periods).skew() diff --git a/pandas_ta/statistics/stdev.py b/pandas_ta/statistics/stdev.py index cc50662..a725faf 100644 --- a/pandas_ta/statistics/stdev.py +++ b/pandas_ta/statistics/stdev.py @@ -7,11 +7,13 @@ from pandas_ta.utils import get_offset, verify_series def stdev(close, length=None, ddof=1, offset=None, **kwargs): """Indicator: Standard Deviation""" # Validate Arguments - close = verify_series(close) length = int(length) if length and length > 0 else 30 ddof = int(ddof) if ddof >= 0 and ddof < length else 1 + close = verify_series(close, length) offset = get_offset(offset) + if close is None: return + # Calculate Result stdev = variance(close=close, length=length, ddof=ddof).apply(npsqrt) diff --git a/pandas_ta/statistics/variance.py b/pandas_ta/statistics/variance.py index fadf9f7..61d35de 100644 --- a/pandas_ta/statistics/variance.py +++ b/pandas_ta/statistics/variance.py @@ -5,13 +5,14 @@ from pandas_ta.utils import get_offset, verify_series def variance(close, length=None, ddof=None, offset=None, **kwargs): """Indicator: Variance""" # Validate Arguments - close = verify_series(close) length = int(length) if length and length > 1 else 30 ddof = int(ddof) if ddof and ddof >= 0 and ddof < length else 0 - min_periods = int(kwargs["min_periods"]) if "min_periods" in kwargs and kwargs["min_periods"] is not None else length + close = verify_series(close, max(length, min_periods)) offset = get_offset(offset) + if close is None: return + # Calculate Result variance = close.rolling(length, min_periods=min_periods).var(ddof) diff --git a/pandas_ta/statistics/zscore.py b/pandas_ta/statistics/zscore.py index 9ff2897..cc44f5e 100644 --- a/pandas_ta/statistics/zscore.py +++ b/pandas_ta/statistics/zscore.py @@ -7,11 +7,13 @@ from pandas_ta.utils import get_offset, verify_series def zscore(close, length=None, std=None, offset=None, **kwargs): """Indicator: Z Score""" # Validate Arguments - close = verify_series(close) length = int(length) if length and length > 1 else 30 std = float(std) if std and std > 1 else 1 + close = verify_series(close, length) offset = get_offset(offset) + if close is None: return + # Calculate Result std *= stdev(close=close, length=length, **kwargs) mean = sma(close=close, length=length, **kwargs) diff --git a/pandas_ta/trend/adx.py b/pandas_ta/trend/adx.py index 254519c..1e129ff 100644 --- a/pandas_ta/trend/adx.py +++ b/pandas_ta/trend/adx.py @@ -1,21 +1,24 @@ # -*- coding: utf-8 -*- from pandas import DataFrame -from pandas_ta.overlap import rma +from pandas_ta.overlap import ma from pandas_ta.volatility import atr from pandas_ta.utils import get_drift, get_offset, verify_series, zero -def adx(high, low, close, length=None, scalar=None, drift=None, offset=None, **kwargs): +def adx(high, low, close, length=None, scalar=None, mamode=None, drift=None, offset=None, **kwargs): """Indicator: ADX""" # Validate Arguments - high = verify_series(high) - low = verify_series(low) - close = verify_series(close) length = length if length and length > 0 else 14 + mamode = mamode if isinstance(mamode, str) else "rma" scalar = float(scalar) if scalar else 100 + high = verify_series(high, length) + low = verify_series(low, length) + close = verify_series(close, length) drift = get_drift(drift) offset = get_offset(offset) + if high is None or low is None or close is None: return + # Calculate Result atr_ = atr(high=high, low=low, close=close, length=length) @@ -29,11 +32,11 @@ def adx(high, low, close, length=None, scalar=None, drift=None, offset=None, **k neg = neg.apply(zero) k = scalar / atr_ - dmp = k * rma(close=pos, length=length) - dmn = k * rma(close=neg, length=length) + dmp = k * ma(mamode, pos, length=length) + dmn = k * ma(mamode, neg, length=length) dx = scalar * (dmp - dmn).abs() / (dmp + dmn) - adx = rma(close=dx, length=length) + adx = ma(mamode, dx, length=length) # Offset if offset != 0: diff --git a/pandas_ta/trend/amat.py b/pandas_ta/trend/amat.py index 5a9138e..3761db0 100644 --- a/pandas_ta/trend/amat.py +++ b/pandas_ta/trend/amat.py @@ -6,15 +6,18 @@ from pandas_ta.overlap import ma from pandas_ta.utils import get_offset, verify_series -def amat(close=None, fast=None, slow=None, mamode=None, lookback=None, offset=None, **kwargs): +def amat(close=None, fast=None, slow=None, mamode=None, lookback=None, slope_length=None, offset=None, **kwargs): """Indicator: Archer Moving Averages Trends (AMAT)""" # Validate Arguments - close = verify_series(close) fast = int(fast) if fast and fast > 0 else 8 slow = int(slow) if slow and slow > 0 else 21 lookback = int(lookback) if lookback and lookback > 0 else 2 - mamode = mamode if isinstance(mamode, str) else "ema" + mamode = mamode.lower() if isinstance(mamode, str) else "ema" + close = verify_series(close, max(fast, slow, lookback)) offset = get_offset(offset) + if "length" in kwargs: kwargs.pop("length") + + if close is None: return # # Calculate Result fast_ma = ma(mamode, close, length=fast, **kwargs) @@ -38,10 +41,9 @@ def amat(close=None, fast=None, slow=None, mamode=None, lookback=None, offset=No mas_short.fillna(method=kwargs["fill_method"], inplace=True) # Prepare DataFrame to return - _lmode = mamode.lower()[0] amatdf = DataFrame({ - f"AMAT{_lmode}_{mas_long.name}": mas_long, - f"AMAT{_lmode}_{mas_short.name}": mas_short + f"AMAT{mamode[0]}_{mas_long.name}": mas_long, + f"AMAT{mamode[0]}_{mas_short.name}": mas_short }) # Name and Categorize it diff --git a/pandas_ta/trend/aroon.py b/pandas_ta/trend/aroon.py index c974ea6..0069744 100644 --- a/pandas_ta/trend/aroon.py +++ b/pandas_ta/trend/aroon.py @@ -7,12 +7,14 @@ from pandas_ta.utils import recent_maximum_index, recent_minimum_index def aroon(high, low, length=None, scalar=None, offset=None, **kwargs): """Indicator: Aroon & Aroon Oscillator""" # Validate Arguments - high = verify_series(high) - low = verify_series(low) length = length if length and length > 0 else 14 scalar = float(scalar) if scalar else 100 + high = verify_series(high, length) + low = verify_series(low, length) offset = get_offset(offset) + if high is None or low is None: return + # Calculate Result periods_from_hh = high.rolling(length + 1).apply(recent_maximum_index, raw=True) periods_from_ll = low.rolling(length + 1).apply(recent_minimum_index, raw=True) diff --git a/pandas_ta/trend/chop.py b/pandas_ta/trend/chop.py index e593030..8b24cd6 100644 --- a/pandas_ta/trend/chop.py +++ b/pandas_ta/trend/chop.py @@ -1,6 +1,5 @@ # -*- coding: utf-8 -*- from numpy import log10 as npLog10 -from pandas import DataFrame from pandas_ta.volatility import atr from pandas_ta.utils import get_offset, get_drift, verify_series @@ -8,16 +7,17 @@ from pandas_ta.utils import get_offset, get_drift, verify_series def chop(high, low, close, length=None, atr_length=None, scalar=None, drift=None, offset=None, **kwargs): """Indicator: Choppiness Index (CHOP)""" # Validate Arguments - high = verify_series(high) - low = verify_series(low) - close = verify_series(close) length = int(length) if length and length > 0 else 14 - atr_length = int( - atr_length) if atr_length is not None and atr_length > 0 else 1 + atr_length = int(atr_length) if atr_length is not None and atr_length > 0 else 1 scalar = float(scalar) if scalar else 100 + high = verify_series(high, length) + low = verify_series(low, length) + close = verify_series(close, length) drift = get_drift(drift) offset = get_offset(offset) + if high is None or low is None or close is None: return + # Calculate Result diff = high.rolling(length).max() - low.rolling(length).min() @@ -71,11 +71,11 @@ Args: high (pd.Series): Series of 'high's low (pd.Series): Series of 'low's close (pd.Series): Series of 'close's - length (int): It's period. Default: 14 - atr_length (int): Length for ATR. Default: 1 - scalar (float): How much to magnify. Default: 100 - drift (int): The difference period. Default: 1 - offset (int): How many periods to offset the result. Default: 0 + length (int): It's period. Default: 14 + atr_length (int): Length for ATR. Default: 1 + scalar (float): How much to magnify. Default: 100 + drift (int): The difference period. Default: 1 + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/trend/cksp.py b/pandas_ta/trend/cksp.py index aa4fe55..88dde58 100644 --- a/pandas_ta/trend/cksp.py +++ b/pandas_ta/trend/cksp.py @@ -7,14 +7,17 @@ from pandas_ta.utils import get_offset, verify_series def cksp(high, low, close, p=None, x=None, q=None, offset=None, **kwargs): """Indicator: Chande Kroll Stop (CKSP)""" # Validate Arguments - high = verify_series(high) - low = verify_series(low) - close = verify_series(close) p = int(p) if p and p > 0 else 10 x = float(x) if x and x > 0 else 1 q = int(q) if q and q > 0 else 9 + _length = max(p, q, x) + high = verify_series(high, _length) + low = verify_series(low, _length) + close = verify_series(close, _length) offset = get_offset(offset) + if high is None or low is None or close is None: return + # Calculate Result atr_ = atr(high=high, low=low, close=close, length=p) @@ -54,10 +57,9 @@ def cksp(high, low, close, p=None, x=None, q=None, offset=None, **kwargs): cksp.__doc__ = \ """Chande Kroll Stop (CKSP) -The Tushar Chande and Stanley Kroll in their book -“The New Technical Trader”. It is a trend-following indicator, -identifying your stop by calculating the average true range of -the recent market volatility. +The Tushar Chande and Stanley Kroll in their book “The New Technical Trader”. +It is a trend-following indicator, identifying your stop by calculating the +average true range of the recent market volatility. Sources: https://www.multicharts.com/discussion/viewtopic.php?t=48914 @@ -75,10 +77,10 @@ Calculation: Args: close (pd.Series): Series of 'close's - p (int): ATR and first stop period. Default: 10 - x (float): ATR scalar. Default: 1 - q (int): Second stop period. Default: 9 - offset (int): How many periods to offset the result. Default: 0 + p (int): ATR and first stop period. Default: 10 + x (float): ATR scalar. Default: 1 + q (int): Second stop period. Default: 9 + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/trend/decay.py b/pandas_ta/trend/decay.py index 8055102..f4b57fb 100644 --- a/pandas_ta/trend/decay.py +++ b/pandas_ta/trend/decay.py @@ -1,5 +1,5 @@ # -*- coding: utf-8 -*- -from math import exp +from numpy import exp as npExp from pandas import DataFrame from pandas_ta.utils import get_offset, verify_series @@ -7,16 +7,18 @@ from pandas_ta.utils import get_offset, verify_series def decay(close, kind=None, length=None, mode=None, offset=None, **kwargs): """Indicator: Decay""" # Validate Arguments - close = verify_series(close) length = int(length) if length and length > 0 else 5 mode = mode.lower() if isinstance(mode, str) else "linear" + close = verify_series(close, length) offset = get_offset(offset) + if close is None: return + # Calculate Result _mode = "L" if mode == "exp" or kind == "exponential": _mode = "EXP" - diff = close.shift(1) - exp(-length) + diff = close.shift(1) - npExp(-length) else: # "linear" diff = close.shift(1) - (1 / length) diff[0] = close[0] diff --git a/pandas_ta/trend/decreasing.py b/pandas_ta/trend/decreasing.py index 695ac2f..ba0e0a9 100644 --- a/pandas_ta/trend/decreasing.py +++ b/pandas_ta/trend/decreasing.py @@ -5,19 +5,22 @@ from pandas_ta.utils import get_offset, verify_series def decreasing(close, length=None, strict=None, asint=None, offset=None, **kwargs): """Indicator: Decreasing""" # Validate Arguments - close = verify_series(close) length = int(length) if length and length > 0 else 1 strict = strict if isinstance(strict, bool) else False asint = asint if isinstance(asint, bool) else True + close = verify_series(close, length) offset = get_offset(offset) + if close is None: return + def stricly_decreasing(series, n): return all([i > j for i,j in zip(series[-n:], series[1:])]) # Calculate Result if strict: # Returns value as float64? Have to cast to bool - decreasing = close.rolling(length, min_periods=length).apply(stricly_decreasing, args=(length,), raw=False) + decreasing = close.rolling(length, min_periods=length) \ + .apply(stricly_decreasing, args=(length,), raw=False) decreasing.fillna(0, inplace=True) decreasing = decreasing.astype(bool) else: @@ -46,7 +49,10 @@ def decreasing(close, length=None, strict=None, asint=None, offset=None, **kwarg decreasing.__doc__ = \ """Decreasing -Returns True if the series is decreasing over a period, False otherwise. If the kwarg 'strict' is True, it returns True if it is continuously decreasing over the period. When using the kwarg 'asint', then it returns 1 for True or 0 for False. +Returns True if the series is decreasing over a period, False otherwise. +If the kwarg 'strict' is True, it returns True if it is continuously decreasing +over the period. When using the kwarg 'asint', then it returns 1 for True +or 0 for False. Calculation: if strict: diff --git a/pandas_ta/trend/dpo.py b/pandas_ta/trend/dpo.py index 2dccb45..a353469 100644 --- a/pandas_ta/trend/dpo.py +++ b/pandas_ta/trend/dpo.py @@ -6,10 +6,12 @@ from pandas_ta.utils import get_offset, verify_series def dpo(close, length=None, centered=True, offset=None, **kwargs): """Indicator: Detrend Price Oscillator (DPO)""" # Validate Arguments - close = verify_series(close) length = int(length) if length and length > 0 else 20 + close = verify_series(close, length) offset = get_offset(offset) + if close is None: return + # Calculate Result t = int(0.5 * length) + 1 ma = sma(close, length) @@ -58,9 +60,9 @@ Calculation: Args: close (pd.Series): Series of 'close's - length (int): It's period. Default: 1 - centered (bool): Shift the dpo back by int(0.5 * length) + 1. Default: True - offset (int): How many periods to offset the result. Default: 0 + length (int): It's period. Default: 1 + centered (bool): Shift the dpo back by int(0.5 * length) + 1. Default: True + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/trend/increasing.py b/pandas_ta/trend/increasing.py index 73120a6..d338912 100644 --- a/pandas_ta/trend/increasing.py +++ b/pandas_ta/trend/increasing.py @@ -5,19 +5,22 @@ from pandas_ta.utils import get_offset, verify_series def increasing(close, length=None, strict=None, asint=None, offset=None, **kwargs): """Indicator: Increasing""" # Validate Arguments - close = verify_series(close) length = int(length) if length and length > 0 else 1 strict = strict if isinstance(strict, bool) else False asint = asint if isinstance(asint, bool) else True + close = verify_series(close, length) offset = get_offset(offset) + if close is None: return + def stricly_increasing(series, n): return all([i < j for i,j in zip(series[-n:], series[1:])]) # Calculate Result if strict: # Returns value as float64? Have to cast to bool - increasing = close.rolling(length, min_periods=length).apply(stricly_increasing, args=(length,), raw=False) + increasing = close.rolling(length, min_periods=length) \ + .apply(stricly_increasing, args=(length,), raw=False) increasing.fillna(0, inplace=True) increasing = increasing.astype(bool) else: @@ -46,7 +49,10 @@ def increasing(close, length=None, strict=None, asint=None, offset=None, **kwarg increasing.__doc__ = \ """Increasing -Returns True if the series is increasing over a period, False otherwise. If the kwarg 'strict' is True, it returns True if it is continuously increasing over the period. When using the kwarg 'asint', then it returns 1 for True or 0 for False. +Returns True if the series is increasing over a period, False otherwise. +If the kwarg 'strict' is True, it returns True if it is continuously increasing +over the period. When using the kwarg 'asint', then it returns 1 for True +or 0 for False. Calculation: if strict: diff --git a/pandas_ta/trend/long_run.py b/pandas_ta/trend/long_run.py index 65f59ec..0bb0431 100644 --- a/pandas_ta/trend/long_run.py +++ b/pandas_ta/trend/long_run.py @@ -7,11 +7,13 @@ from pandas_ta.utils import get_offset, verify_series def long_run(fast, slow, length=None, offset=None, **kwargs): """Indicator: Long Run""" # Validate Arguments - fast = verify_series(fast) - slow = verify_series(slow) length = int(length) if length and length > 0 else 2 + fast = verify_series(fast, length) + slow = verify_series(slow, length) offset = get_offset(offset) + if fast is None or slow is None: return + # Calculate Result pb = increasing(fast, length) & decreasing(slow, length) # potential bottom or bottom bi = increasing(fast, length) & increasing(slow, length) # fast and slow are increasing diff --git a/pandas_ta/trend/psar.py b/pandas_ta/trend/psar.py index 542c81b..9a5071c 100644 --- a/pandas_ta/trend/psar.py +++ b/pandas_ta/trend/psar.py @@ -35,47 +35,47 @@ def psar(high, low, close=None, af=None, max_af=None, offset=None, **kwargs): # Calculate Result for i in range(2, m): reverse = False - _af[i] = af + _af.iloc[i] = af if bullish: - sar[i] = sar[i - 1] + af * (high_point - sar[i - 1]) + sar.iloc[i] = sar.iloc[i - 1] + af * (high_point - sar.iloc[i - 1]) - if low[i] < sar[i]: + if low.iloc[i] < sar.iloc[i]: bullish, reverse, af = False, True, af0 - sar[i] = high_point - low_point = low[i] + sar.iloc[i] = high_point + low_point = low.iloc[i] else: - sar[i] = sar[i - 1] + af * (low_point - sar[i - 1]) + sar.iloc[i] = sar.iloc[i - 1] + af * (low_point - sar.iloc[i - 1]) - if high[i] > sar[i]: + if high.iloc[i] > sar.iloc[i]: bullish, reverse, af = True, True, af0 - sar[i] = low_point - high_point = high[i] + sar.iloc[i] = low_point + high_point = high.iloc[i] - reversal[i] = reverse + reversal.iloc[i] = reverse if not reverse: if bullish: - if high[i] > high_point: - high_point = high[i] + if high.iloc[i] > high_point: + high_point = high.iloc[i] af = min(af + af0, max_af) - if low[i - 1] < sar[i]: - sar[i] = low[i - 1] - if low[i - 2] < sar[i]: - sar[i] = low[i - 2] + if low.iloc[i - 1] < sar.iloc[i]: + sar.iloc[i] = low.iloc[i - 1] + if low.iloc[i - 2] < sar.iloc[i]: + sar.iloc[i] = low.iloc[i - 2] else: - if low[i] < low_point: - low_point = low[i] + if low.iloc[i] < low_point: + low_point = low.iloc[i] af = min(af + af0, max_af) - if high[i - 1] > sar[i]: - sar[i] = high[i - 1] - if high[i - 2] > sar[i]: - sar[i] = high[i - 2] + if high.iloc[i - 1] > sar.iloc[i]: + sar.iloc[i] = high.iloc[i - 1] + if high.iloc[i - 2] > sar.iloc[i]: + sar.iloc[i] = high.iloc[i - 2] if bullish: - long[i] = sar[i] + long.iloc[i] = sar.iloc[i] else: - short[i] = sar[i] + short.iloc[i] = sar.iloc[i] # Offset if offset != 0: @@ -128,9 +128,9 @@ Args: high (pd.Series): Series of 'high's low (pd.Series): Series of 'low's close (pd.Series, optional): Series of 'close's. Optional - af (float): Acceleration Factor. Default: 0.02 - max_af (float): Maximum Acceleration Factor. Default: 0.2 - offset (int): How many periods to offset the result. Default: 0 + af (float): Acceleration Factor. Default: 0.02 + max_af (float): Maximum Acceleration Factor. Default: 0.2 + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/trend/qstick.py b/pandas_ta/trend/qstick.py index 1d850c6..1f1676d 100644 --- a/pandas_ta/trend/qstick.py +++ b/pandas_ta/trend/qstick.py @@ -6,11 +6,13 @@ from pandas_ta.utils import get_offset, non_zero_range, verify_series def qstick(open_, close, length=None, offset=None, **kwargs): """Indicator: Q Stick""" # Validate Arguments - open_ = verify_series(open_) - close = verify_series(close) length = int(length) if length and length > 0 else 10 - offset = get_offset(offset) ma = kwargs.pop("ma", "sma") + open_ = verify_series(open_, length) + close = verify_series(close, length) + offset = get_offset(offset) + + if open_ is None or close is None: return # Calculate Result diff = non_zero_range(close, open_) @@ -46,8 +48,8 @@ def qstick(open_, close, length=None, offset=None, **kwargs): qstick.__doc__ = \ """Q Stick -The Q Stick indicator, developed by Tushar Chande, attempts to quantify and identify -trends in candlestick charts. +The Q Stick indicator, developed by Tushar Chande, attempts to quantify and +identify trends in candlestick charts. Sources: https://library.tradingtechnologies.com/trade/chrt-ti-qstick.html @@ -61,9 +63,9 @@ Calculation: Args: open (pd.Series): Series of 'open's close (pd.Series): Series of 'close's - length (int): It's period. Default: 1 - ma (str): The type of moving average to use. Default: None, which is 'sma' - offset (int): How many periods to offset the result. Default: 0 + length (int): It's period. Default: 1 + ma (str): The type of moving average to use. Default: None, which is 'sma' + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/trend/short_run.py b/pandas_ta/trend/short_run.py index 581e30d..3e5759a 100644 --- a/pandas_ta/trend/short_run.py +++ b/pandas_ta/trend/short_run.py @@ -7,11 +7,13 @@ from pandas_ta.utils import get_offset, verify_series def short_run(fast, slow, length=None, offset=None, **kwargs): """Indicator: Short Run""" # Validate Arguments - fast = verify_series(fast) - slow = verify_series(slow) length = int(length) if length and length > 0 else 2 + fast = verify_series(fast, length) + slow = verify_series(slow, length) offset = get_offset(offset) + if fast is None or slow is None: return + # Calculate Result pt = decreasing(fast, length) & increasing(slow, length) # potential top or top bd = decreasing(fast, length) & decreasing(slow, length) # fast and slow are decreasing diff --git a/pandas_ta/trend/ttm_trend.py b/pandas_ta/trend/ttm_trend.py index 3d5aec1..c294d02 100644 --- a/pandas_ta/trend/ttm_trend.py +++ b/pandas_ta/trend/ttm_trend.py @@ -7,12 +7,14 @@ from pandas_ta.utils import get_offset, verify_series def ttm_trend(high, low, close, length=None, offset=None, **kwargs): """Indicator: TTM Trend (TTM_TRND)""" # Validate arguments - high = verify_series(high) - low = verify_series(low) - close = verify_series(close) length = int(length) if length and length > 0 else 6 + high = verify_series(high, length) + low = verify_series(low, length) + close = verify_series(close, length) offset = get_offset(offset) + if high is None or low is None or close is None: return + # Calculate Result trend_avg = hl2(high, low) for i in range(1, length): @@ -72,8 +74,8 @@ Args: high (pd.Series): Series of 'high's low (pd.Series): Series of 'low's close (pd.Series): Series of 'close's - length (int): It's period. Default: 6 - offset (int): How many periods to offset the result. Default: 0 + length (int): It's period. Default: 6 + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) fill_method (value, optional): Type of fill method diff --git a/pandas_ta/trend/vortex.py b/pandas_ta/trend/vortex.py index 38a147e..b6ba4c7 100644 --- a/pandas_ta/trend/vortex.py +++ b/pandas_ta/trend/vortex.py @@ -7,14 +7,17 @@ from pandas_ta.utils import get_drift, get_offset, verify_series, zero def vortex(high, low, close, length=None, drift=None, offset=None, **kwargs): """Indicator: Vortex""" # Validate arguments - high = verify_series(high) - low = verify_series(low) - close = verify_series(close) length = length if length and length > 0 else 14 min_periods = int(kwargs["min_periods"]) if "min_periods" in kwargs and kwargs["min_periods"] is not None else length + _length = max(length, min_periods) + high = verify_series(high, _length) + low = verify_series(low, _length) + close = verify_series(close, _length) drift = get_drift(drift) offset = get_offset(offset) + if high is None or low is None or close is None: return + # Calculate Result tr = true_range(high=high, low=low, close=close) tr_sum = tr.rolling(length, min_periods=min_periods).sum() @@ -78,9 +81,9 @@ Args: high (pd.Series): Series of 'high's low (pd.Series): Series of 'low's close (pd.Series): Series of 'close's - length (int): ROC 1 period. Default: 14 - drift (int): The difference period. Default: 1 - offset (int): How many periods to offset the result. Default: 0 + length (int): ROC 1 period. Default: 14 + drift (int): The difference period. Default: 1 + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/utils/__init__.py b/pandas_ta/utils/__init__.py index 2705022..5295cf5 100644 --- a/pandas_ta/utils/__init__.py +++ b/pandas_ta/utils/__init__.py @@ -1,6 +1,7 @@ # -*- coding: utf-8 -*- from ._candles import * from ._core import * +from ._data import * from ._math import * from ._signals import * from ._time import * diff --git a/pandas_ta/utils/_candles.py b/pandas_ta/utils/_candles.py index a40b853..663977b 100644 --- a/pandas_ta/utils/_candles.py +++ b/pandas_ta/utils/_candles.py @@ -15,5 +15,5 @@ def high_low_range(high: Series, low: Series) -> Series: return non_zero_range(high, low) -def real_body(close: Series, open_: Series) -> Series: +def real_body(open_: Series, close: Series) -> Series: return non_zero_range(close, open_) diff --git a/pandas_ta/utils/_core.py b/pandas_ta/utils/_core.py index 62895ca..ba48b67 100644 --- a/pandas_ta/utils/_core.py +++ b/pandas_ta/utils/_core.py @@ -1,12 +1,19 @@ # -*- coding: utf-8 -*- +import re as re_ from pathlib import Path from sys import float_info as sflt from numpy import argmax, argmin +from numpy import NaN as npNaN from pandas import DataFrame, Series from pandas.api.types import is_datetime64_any_dtype +def _camelCase2Title(x: str): + """https://stackoverflow.com/questions/5020906/python-convert-camel-case-to-space-delimited-using-regex-and-taking-acronyms-in""" + return re_.sub("([a-z])([A-Z])","\g<1> \g<2>", x).title() + + def category_files(category: str) -> list: """Helper function to return all filenames in the category directory.""" files = [ @@ -105,7 +112,8 @@ def unsigned_differences(series: Series, amount: int = None, **kwargs) -> Series return positive, negative -def verify_series(series: Series) -> Series: - """If a Pandas Series return it.""" +def verify_series(series: Series, min_length: int = None) -> Series: + """If a Pandas Series and it meets the min_length of the indicator return it.""" + has_length = min_length is not None and isinstance(min_length, int) if series is not None and isinstance(series, Series): - return series + return None if has_length and series.size < min_length else series \ No newline at end of file diff --git a/pandas_ta/utils/_data.py b/pandas_ta/utils/_data.py new file mode 100644 index 0000000..589733f --- /dev/null +++ b/pandas_ta/utils/_data.py @@ -0,0 +1,312 @@ +# -*- coding: utf-8 -*- +# from alphaVantageAPI import alphavantage +from pandas import DataFrame +from pandas_ta import Imports, RATE, version +from ._core import _camelCase2Title +from ._time import ytd_df + + +def av(ticker: str, **kwargs): + print(f"[!] kwargs: {kwargs}") + verbose = kwargs.pop("verbose", False) + kind = kwargs.pop("kind", "history") + kind = kind.lower() + interval = kwargs.pop("interval", "D") + show = kwargs.pop("show", None) + # last = kwargs.pop("last", RATE["TRADING_DAYS_PER_YEAR"]) + + ticker = ticker.upper() if ticker is not None and isinstance(ticker, str) else None + + if Imports["alphaVantage-api"] and ticker is not None: + import alphaVantageAPI as AV + AVC = {"api_key": "YOUR API KEY", "clean": True, "export": False, "output_size": "full", "premium": False} + _config = kwargs.pop("av_kwargs", AVC) + av = AV.AlphaVantage(**_config) + + period = kwargs.pop("period", av.output_size) + + _all, div = ["all"], "=" * 53 # Max div width is 80 + + if kind in _all or verbose: pass + + if kind in _all + ["history", "h"]: + if verbose: + print("\n==== Chart History " + div + f"\n[*] Pandas TA v{version} & alphaVantage-api") + print(f"[+] Downloading {ticker}[{interval}:{period}] from {av.API_NAME} (https://www.alphavantage.co/)") + df = av.data(ticker, interval) + df.name = ticker + if show is not None and isinstance(show, int) and show > 0: + print(f"\n{df.name}\n{df.tail(show)}\n") + return df + + return DataFrame() + + +def yf(ticker: str, **kwargs): + """yf - yfinance wrapper + + It retrieves market data (ohlcv) from Yahoo Finance using yfinance. + To install yfinance. (pip install yfinance) This method can also pull + additional data using the 'kind' kwarg. By default kind=None and retrieves + Historical Chart Data. + + Other options of 'kind' include: + * All: "all" + - Prints everything below but only returns Chart History to Pandas TA + * Company Information: "info" + * Institutional Holders: "institutional_holders" or "ih" + * Major Holders: "major_holders" or "mh" + * Mutual Fund Holders: "mutualfund_holders" or "mfh" + * Recommendations (YTD): "recommendations" or "rec" + * Earnings Calendar: "calendar" or "cal" + * Earnings: "earnings" or "earn" + * Sustainability/ESG Scores: "sustainability", "sus" or "esg" + * Financials: "financials" or "fin" + - Returns in order: Income Statement, Balance Sheet and Cash Flow + * Option Chain: "option_chain" or "oc" + - Uses the nearest expiration date by default + - Change the expiration date using kwarg "exp" + - Show ITM options, set kwarg "itm" to True. Or OTM options, set + kwarg "itm" to False. + * Chart History: + - The only data returned to Pandas TA. + + Args: + ticker (str): Any string for a ticker you would use with yfinance. + Default: "SPY" + Kwargs: + desc (bool): Will print Company Description when printing Company + Information. Default: False + exp (str): Used to print other Option Chains for the given Expiration + Date. Default: Nearest Expiration Date for the Option Chains + interval (str): A yfinance argument. Default: "1d" + itm (bool): When printing Option Chains, shows ITM Options when True. + When False, it shows OTM Options: Default: None + kind (str): Options see above. Default: None + period (str): A yfinance argument. Default: "max" + proxy (dict): Proxy for yfinance to use. Default: {} + show (int > 0): How many last rows of Chart History to show. + Default: None + snd (int): How many recent Splits and Dividends to show in Company + Information. Default: 5 + verbose (bool): Prints Company Information "info" and a Chart History + header to the screen. Default: False + + Returns: + Exits if the DataFrame is empty or None + Otherwise it returns a DataFrame of the Chart History + """ + verbose = kwargs.pop("verbose", False) + if ticker is not None and isinstance(ticker, str) and len(ticker): + ticker = ticker.upper() + else: + ticker = "SPY" + + kind = kwargs.pop("kind", None) + if kind is not None and isinstance(kind, str) and len(kind): + kind = kind.lower() + + period = kwargs.pop("period", "max") + interval = kwargs.pop("interval", "1d") + proxy = kwargs.pop("proxy", {}) + show = kwargs.pop("show", None) + + if not Imports["yfinance"]: + print(f"[X] Please install yfinance to use this method. (pip install yfinance)") + return + if Imports["yfinance"] and ticker is not None: + import yfinance as yfra + yfra.pdr_override() + + # Ticker Info + yfd = yfra.Ticker(ticker) + + try: + ticker_info = yfd.info + except KeyError as ke: + print(f"[X] Ticker '{ticker}' not found.") + return + + infodf = DataFrame.from_dict(ticker_info, orient="index") + infodf.name, infodf.columns = ticker, [ticker] + + # Dividends and Splits + dividends, splits = yfd.splits, yfd.dividends + + _all, div = ["all"], "=" * 53 # Max div width is 80 + if kind in _all + ["info"] or verbose: + description = kwargs.pop("desc", False) + snd_length = kwargs.pop("snd", 5) + + print("\n==== Company Information " + div) + print(f"{ticker_info['longName']} ({ticker_info['shortName']})") + if description: + print(f"{ticker_info['longBusinessSummary']}\n") + if "address1" in ticker_info and len(ticker_info["address1"]): + if "address2" in ticker_info and len(ticker_info["address2"]): + print(f"{ticker_info['address1']} {ticker_info['address2']}") + else: + print(f"{ticker_info['address1']}") + if "city" in ticker_info and len(ticker_info["city"]): + print(f"{ticker_info['city']}, {ticker_info['state']} {ticker_info['zip']}, {ticker_info['country']}") + else: + print(f"{ticker_info['state']} {ticker_info['zip']}, {ticker_info['country']}") + print(f"Phone (Fax): {ticker_info['phone']} ({ticker_info['fax'] if 'fax' in ticker_info else 'N/A'})") + if "website" in ticker_info and "fullTimeEmployees" in ticker_info: + print(f"Website: {ticker_info['website']} FT Employees: {ticker_info['fullTimeEmployees']:,}") + if "sector" in ticker_info and len(ticker_info["sector"]): + print(f"Sector | Industry: {ticker_info['sector']} | {ticker_info['industry']}") + + print("\n==== Market Information " + div) + _category = f" | {ticker_info['category']}" if "category" in ticker_info and ticker_info["category"] is not None else "" + print(f"Market | Exchange | Symbol{' | Category' if 'category' in ticker_info and ticker_info['category'] is not None else ''}: {ticker_info['market'].split('_')[0].upper()} | {ticker_info['exchange']} | {ticker_info['symbol']}{_category}") + + if "marketCap" in ticker_info and ticker_info["marketCap"] is not None: + print(f"Market Cap.: {ticker_info['marketCap']:,} ({ticker_info['marketCap']/1000000:,.2f} MM)") + + print(f"\nShares Outstanding | Float: {ticker_info['sharesOutstanding']:,} | {ticker_info['floatShares']:,}") if "sharesOutstanding" in ticker_info else None + if "sharesShort" in ticker_info and "shortRatio" in ticker_info and ticker_info["sharesShort"] is not None and ticker_info["shortRatio"] is not None: + print(f"Shares Short (Ratio): {ticker_info['sharesShort']:,} ({ticker_info['shortRatio']})") + if "52WeekChange" in ticker_info and ticker_info['52WeekChange'] is not None: + print(f"\n52Wk % Change: {100 * ticker_info['52WeekChange']:.4f}%") + if "SandP52WeekChange" in ticker_info and ticker_info['SandP52WeekChange'] is not None: + print(f"52Wk % Change vs S&P500: {100 *(ticker_info['52WeekChange'] - ticker_info['SandP52WeekChange']):.4f}%") + if "fiftyTwoWeekHigh" in ticker_info and "fiftyTwoWeekLow" in ticker_info and "previousClose" in ticker_info: # or 'regularMarketPrice' + print(f"52Wk Range (% from 52Wk Low): {ticker_info['fiftyTwoWeekLow']} - {ticker_info['fiftyTwoWeekHigh']} : {ticker_info['fiftyTwoWeekHigh'] - ticker_info['fiftyTwoWeekLow']:.4f} ({100 * (ticker_info['previousClose'] / ticker_info['fiftyTwoWeekLow'] - 1):.4f}%)") + if "beta" in ticker_info and ticker_info['beta'] is not None: + print(f"Beta (3Yr): {ticker_info['beta']} ({ticker_info['beta3Year']})") + + if not dividends.empty: + dividends.name = "Value" + total_dividends = dividends.size + dividendsdf = DataFrame(dividends.tail(snd_length)[::-1]).T + print(f"\nDividends (Last {snd_length} of {total_dividends}):\n{dividendsdf}") + + if not splits.empty: + splits.name = "Ratio" + total_splits = splits.size + splitsdf = DataFrame(splits.tail(snd_length)[::-1]).T + print(f"\nStock Splits (Last {snd_length} of {total_splits}):\n{splitsdf}") + + print("\n==== Price Information " + div) + print(f"OHLC: {ticker_info['open']:.4f}, {ticker_info['dayHigh']:.4f}, {ticker_info['dayLow']:.4f}, {ticker_info['previousClose']:.4f} ({100 * ((ticker_info['previousClose'] / ticker_info['open'] - 1)):.4f}%)") + print(f"Volume: {ticker_info['volume']:,} AvgVol (10Day): {ticker_info['averageVolume']:,} ({ticker_info['averageDailyVolume10Day']:,})") + print(f"Bid | Ask | Spread: {ticker_info['bid']} x {ticker_info['bidSize']} | {ticker_info['ask']} x {ticker_info['askSize']} | {ticker_info['ask'] - ticker_info['bid']:.4f}") + + if kind in _all + ["institutional_holders", "ih"]: + ihdf = yfd.institutional_holders + if ihdf is not None and "Date Reported" in ihdf.columns: + ihdf.set_index("Date Reported", inplace=True) + ihdf["Shares"] = ihdf.apply(lambda x: f"{x['Shares']:,}", axis=1) + ihdf["Value"] = ihdf.apply(lambda x: f"{x['Value']:,}", axis=1) + print("\n==== Instl Holders " + div + f"\n{ihdf}") + + if kind in _all + ["major_holders", "mh"]: + mhdf = yfd.major_holders + if mhdf is not None and "Major Holders" in mhdf.columns: + mhdf.columns = ["Percentage", "Major Holders"] + mhdf.set_index("Major Holders", inplace=True) + mhdf["Shares"] = mhdf.apply(lambda x: f"{x['Shares']:,}", axis=1) + mhdf["Value"] = mhdf.apply(lambda x: f"{x['Value']:,}", axis=1) + print("\n==== Major Holders " + div + f"\n{mhdf}") + + if kind in _all + ["mutualfund_holders", "mfh"]: + mfhdf = yfd.get_mutualfund_holders() + if mfhdf is not None and "Holder" in mfhdf.columns: + mfhdf.set_index("Date Reported", inplace=True) + mfhdf["Shares"] = mfhdf.apply(lambda x: f"{x['Shares']:,}", axis=1) + mfhdf["Value"] = mfhdf.apply(lambda x: f"{x['Value']:,}", axis=1) + print("\n==== Mutual Fund Holders" + div + f"\n{mfhdf}") + + if kind in _all + ["recommendations", "rec"]: + recdf = yfd.recommendations + if recdf is not None: + recdf = ytd_df(recdf) + # recdf_grade = recdf["To Grade"].value_counts().T + # recdf_grade.name = "Grades" + print("\n==== Recommendations(YTD)" + div + f"\n{recdf}") + + if kind in _all + ["calendar", "cal"]: + caldf = yfd.calendar + if caldf is not None and "Earnings Date" in caldf.columns: + caldf.set_index("Earnings Date", inplace=True) + print("\n==== Earnings Calendar " + div + f"\n{caldf}") + + if kind in _all + ["earnings", "earn"]: + earndf = yfd.earnings + if not earndf.empty: + earndf["Revenue"] = earndf.apply(lambda x: f"{x['Revenue']:,}", axis=1) + earndf["Earnings"] = earndf.apply(lambda x: f"{x['Earnings']:,}", axis=1) + print("\n==== Earnings " + div + f"\n{earndf}") + + if kind in _all + ["sustainability", "sus", "esg"]: + susdf = yfd.sustainability + if susdf is not None: + susdf.replace({None: False}, inplace=True) + susdf.columns = ["Score"] + susdf.drop(susdf[susdf["Score"] == False].index, inplace=True) + susdf.rename(index=_camelCase2Title, errors="ignore", inplace=True) + susdf.index.name = "Source" + print("\n==== Sustainability/ESG " + div + f"\n{susdf}") + + if kind in _all + ["financials", "fin"]: + print("\n==== Company Financials " + div) + icdf = yfd.financials + bsdf = yfd.balance_sheet + cfdf = yfd.cashflow + if icdf.empty or bsdf.empty or cfdf.empty: + if yfra.__version__ == "0.1.54": + print(f"[!] Ignore if aleady patched. Some tickers do not have financials.") + print(f"[!] Otherwise to enable Company Financials, see yfinance Issue #517 patch.") + print(f"[!] https://github.com/ranaroussi/yfinance/pull/517/files") + else: + if not icdf.empty: print(f"Income Statement:\n{icdf}\n") + if not bsdf.empty: print(f"Balance Sheet:\n{bsdf}\n") + if not cfdf.empty: print(f"Cash Flow:\n{cfdf}\n") + + if kind in _all + ["option_chain", "oc"]: + try: + yfd_options = yfd.options + except IndexError as ie: + yfd_options = None + + if yfd_options is not None: + opt_expirations = list(yfd_options) + itm = kwargs.pop("itm", None) + opt_date = kwargs.pop("exp", opt_expirations[0]) + opt_expirations_str = f"{ticker} Option Expirations:\n\t{', '.join(opt_expirations)}\n" + + print("\n==== Option Chains " + div) + print(opt_expirations_str) + if opt_date not in opt_expirations: + print(f"[X] No Options for {ticker_info['quoteType']} {ticker_info['symbol']}") + else: + option_columns = ["Contract", "Last Trade", "Strike", "Price", "Bid", "Ask", "Change", "Percent Change", "Volume", "OI", "IV", "ITM", "Size", "Currency"] + cp_chain = yfd.option_chain(proxy=proxy) + calls, puts = cp_chain.calls, cp_chain.puts + calls.columns = puts.columns = option_columns + calls.set_index("Contract", inplace=True) + puts.set_index("Contract", inplace=True) + + calls.name = f"{ticker} Calls for {opt_date}" + puts.name = f"{ticker} Puts for {opt_date}" + + if itm is not None: + calls.name, puts.name = f"{calls.name} ITM: {itm}", f"{puts.name} ITM: {itm}" + print(f"{calls.name}\n{calls[calls['ITM'] == itm]}\n\n{puts.name}\n{puts[puts['ITM'] == itm]}") + else: + print(f"{calls.name}\n{calls}\n\n{puts.name}\n{puts}") + + df = yfd.history(period=period, interval=interval, proxy=proxy, **kwargs) + df.name = ticker + if verbose: + print("\n==== Chart History " + div + f"\n[*] Pandas TA v{version} & yfinance v{yfra.__version__}") + print(f"[+] Downloading {ticker}[{interval}:{period}] from Yahoo Finance") + if show is not None and isinstance(show, int) and show > 0: + print(f"\n{df.name}\n{df.tail(show)}\n") + if verbose: print("=" * 80 + "\n") + else: print() + return df + + else: + return DataFrame() diff --git a/pandas_ta/utils/_math.py b/pandas_ta/utils/_math.py index ea6980f..e532b37 100644 --- a/pandas_ta/utils/_math.py +++ b/pandas_ta/utils/_math.py @@ -1,6 +1,6 @@ # -*- coding: utf-8 -*- from functools import reduce -from math import fabs, floor +from math import floor as mfloor from operator import mul from sys import float_info as sflt from typing import List, Optional, Tuple @@ -11,6 +11,8 @@ from numpy import append as npAppend from numpy import array as npArray from numpy import corrcoef as npCorrcoef from numpy import dot as npDot +from numpy import fabs as npFabs +from numpy import floor as npFloor from numpy import exp as npExp from numpy import log as npLog from numpy import NaN as npNaN @@ -27,8 +29,8 @@ from ._core import verify_series def combination(**kwargs: dict) -> int: """https://stackoverflow.com/questions/4941753/is-there-a-math-ncr-function-in-python""" - n = int(fabs(kwargs.pop("n", 1))) - r = int(fabs(kwargs.pop("r", 0))) + n = int(npFabs(kwargs.pop("n", 1))) + r = int(npFabs(kwargs.pop("r", 0))) if kwargs.pop("repetition", False) or kwargs.pop("multichoose", False): n = n + r - 1 @@ -45,7 +47,7 @@ def combination(**kwargs: dict) -> int: def fibonacci(n: int = 2, **kwargs: dict) -> npNdArray: """Fibonacci Sequence as a numpy array""" - n = int(fabs(n)) if n >= 0 else 2 + n = int(npFabs(n)) if n >= 0 else 2 zero = kwargs.pop("zero", False) if zero: @@ -55,7 +57,7 @@ def fibonacci(n: int = 2, **kwargs: dict) -> npNdArray: a, b = 1, 1 result = npArray([a]) - for i in range(0, n): + for _ in range(0, n): a, b = b, a + b result = npAppend(result, a) @@ -119,7 +121,7 @@ def pascals_triangle(n: int = None, **kwargs: dict) -> npNdArray: => weighted: [0.0625, 0.25, 0.375, 0.25, 0.0625] => inverse weighted: [0.9375, 0.75, 0.625, 0.75, 0.9375] """ - n = int(fabs(n)) if n is not None else 0 + n = int(npFabs(n)) if n is not None else 0 # Calculation triangle = npArray([combination(n=n, r=i) for i in range(0, n + 1)]) @@ -146,7 +148,7 @@ def symmetric_triangle(n: int = None, **kwargs: dict) -> Optional[List[int]]: n=4 => triangle: [1, 2, 2, 1] => weighted: [0.16666667 0.33333333 0.33333333 0.16666667] """ - n = int(fabs(n)) if n is not None else 2 + n = int(npFabs(n)) if n is not None else 2 triangle = None if n == 2: @@ -154,10 +156,10 @@ def symmetric_triangle(n: int = None, **kwargs: dict) -> Optional[List[int]]: if n > 2: if n % 2 == 0: - front = [i + 1 for i in range(0, floor(n / 2))] + front = [i + 1 for i in range(0, mfloor(n / 2))] triangle = front + front[::-1] else: - front = [i + 1 for i in range(0, floor(0.5 * (n + 1)))] + front = [i + 1 for i in range(0, mfloor(0.5 * (n + 1)))] triangle = front.copy() front.pop() triangle += front[::-1] diff --git a/pandas_ta/utils/_time.py b/pandas_ta/utils/_time.py index 54a34d1..0696f06 100644 --- a/pandas_ta/utils/_time.py +++ b/pandas_ta/utils/_time.py @@ -3,9 +3,10 @@ from datetime import datetime from time import localtime, perf_counter from typing import Tuple -from pandas import DataFrame, Series, Timestamp +from pandas import DataFrame, DatetimeIndex, Timestamp from pandas_ta import EXCHANGE_TZ, RATE +from pandas_ta.utils import verify_series def df_dates(df: DataFrame, dates: Tuple[str, list] = None) -> DataFrame: @@ -70,11 +71,12 @@ def get_time(exchange: str = "NYSE", full:bool = True, to_string:bool = False) - return s if to_string else print(s) -def total_time(series: Series, tf: str = "years") -> float: - """Calculates the total time of a Series. Options: 'months', 'weeks', - 'days', 'hours', 'minutes' and 'seconds'. Default: 'years'. +def total_time(df: DataFrame, tf: str = "years") -> float: + """Calculates the total time of a DataFrame. Difference of the Last and + First index. Options: 'months', 'weeks', 'days', 'hours', 'minutes' + and 'seconds'. Default: 'years'. Useful for annualization.""" - time_diff = series.index[-1] - series.index[0] + time_diff = df.index[-1] - df.index[0] TimeFrame = { "years": time_diff.days / RATE["TRADING_DAYS_PER_YEAR"], "months": time_diff.days / 30.417, diff --git a/pandas_ta/volatility/__init__.py b/pandas_ta/volatility/__init__.py index e1d9bc8..f637cce 100644 --- a/pandas_ta/volatility/__init__.py +++ b/pandas_ta/volatility/__init__.py @@ -4,6 +4,7 @@ from .accbands import accbands from .atr import atr from .bbands import bbands from .donchian import donchian +from .hwc import hwc from .kc import kc from .massi import massi from .pdist import pdist diff --git a/pandas_ta/volatility/aberration.py b/pandas_ta/volatility/aberration.py index 5a3e4e7..b7326b7 100644 --- a/pandas_ta/volatility/aberration.py +++ b/pandas_ta/volatility/aberration.py @@ -3,19 +3,22 @@ from pandas import DataFrame from .atr import atr from pandas_ta.overlap import hlc3, sma -from pandas_ta.utils import get_offset, non_zero_range, verify_series +from pandas_ta.utils import get_offset, verify_series def aberration(high, low, close, length=None, atr_length=None, offset=None, **kwargs): """Indicator: Aberration (ABER)""" # Validate arguments - high = verify_series(high) - low = verify_series(low) - close = verify_series(close) length = int(length) if length and length > 0 else 5 atr_length = int(atr_length) if atr_length and atr_length > 0 else 15 + _length = max(atr_length, length) + high = verify_series(high, _length) + low = verify_series(low, _length) + close = verify_series(close, _length) offset = get_offset(offset) + if high is None or low is None or close is None: return + # Calculate Result atr_ = atr(high=high, low=low, close=close, length=atr_length) jg = hlc3(high=high, low=low, close=close) @@ -86,9 +89,9 @@ Args: high (pd.Series): Series of 'high's low (pd.Series): Series of 'low's close (pd.Series): Series of 'close's - length (int): The short period. Default: 5 - atr_length (int): The short period. Default: 15 - offset (int): How many periods to offset the result. Default: 0 + length (int): The short period. Default: 5 + atr_length (int): The short period. Default: 15 + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/volatility/accbands.py b/pandas_ta/volatility/accbands.py index 4c38aa4..1ee5045 100644 --- a/pandas_ta/volatility/accbands.py +++ b/pandas_ta/volatility/accbands.py @@ -7,17 +7,19 @@ from pandas_ta.utils import get_drift, get_offset, non_zero_range, verify_series def accbands(high, low, close, length=None, c=None, drift=None, mamode=None, offset=None, **kwargs): """Indicator: Acceleration Bands (ACCBANDS)""" # Validate arguments - high = verify_series(high) - low = verify_series(low) - close = verify_series(close) - high_low_range = non_zero_range(high, low) length = int(length) if length and length > 0 else 20 c = float(c) if c and c > 0 else 4 mamode = mamode if isinstance(mamode, str) else "sma" + high = verify_series(high, length) + low = verify_series(low, length) + close = verify_series(close, length) drift = get_drift(drift) offset = get_offset(offset) + if high is None or low is None or close is None: return + # Calculate Result + high_low_range = non_zero_range(high, low) hl_ratio = high_low_range / (high + low) hl_ratio *= c _lower = low * (1 - hl_ratio) @@ -89,11 +91,11 @@ Args: high (pd.Series): Series of 'high's low (pd.Series): Series of 'low's close (pd.Series): Series of 'close's - length (int): It's period. Default: 10 - c (int): Multiplier. Default: 4 - mamode (str): Two options: None or 'ema'. Default: 'ema' - drift (int): The difference period. Default: 1 - offset (int): How many periods to offset the result. Default: 0 + length (int): It's period. Default: 10 + c (int): Multiplier. Default: 4 + mamode (str): Two options: None or 'ema'. Default: 'ema' + drift (int): The difference period. Default: 1 + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/volatility/atr.py b/pandas_ta/volatility/atr.py index 336ae5a..3123e12 100644 --- a/pandas_ta/volatility/atr.py +++ b/pandas_ta/volatility/atr.py @@ -7,14 +7,16 @@ from pandas_ta.utils import get_drift, get_offset, verify_series def atr(high, low, close, length=None, mamode=None, drift=None, offset=None, **kwargs): """Indicator: Average True Range (ATR)""" # Validate arguments - high = verify_series(high) - low = verify_series(low) - close = verify_series(close) length = int(length) if length and length > 0 else 14 mamode = mamode.lower() if mamode and isinstance(mamode, str) else "rma" + high = verify_series(high, length) + low = verify_series(low, length) + close = verify_series(close, length) drift = get_drift(drift) offset = get_offset(offset) + if high is None or low is None or close is None: return + # Calculate Result tr = true_range(high=high, low=low, close=close, drift=drift) atr = ma(mamode, tr, length=length) @@ -43,8 +45,8 @@ def atr(high, low, close, length=None, mamode=None, drift=None, offset=None, **k atr.__doc__ = \ """Average True Range (ATR) -Averge True Range is used to measure volatility, especially -volatility caused by gaps or limit moves. +Averge True Range is used to measure volatility, especially volatility caused by +gaps or limit moves. Sources: https://www.tradingview.com/wiki/Average_True_Range_(ATR) diff --git a/pandas_ta/volatility/bbands.py b/pandas_ta/volatility/bbands.py index 1904bf2..65f1475 100644 --- a/pandas_ta/volatility/bbands.py +++ b/pandas_ta/volatility/bbands.py @@ -5,21 +5,23 @@ from pandas_ta.statistics import stdev from pandas_ta.utils import get_offset, verify_series -def bbands(close, length=None, std=None, mamode=None, offset=None, **kwargs): +def bbands(close, length=None, std=None, mamode=None, ddof=0, offset=None, **kwargs): """Indicator: Bollinger Bands (BBANDS)""" # Validate arguments - close = verify_series(close) length = int(length) if length and length > 0 else 5 std = float(std) if std and std > 0 else 2.0 mamode = mamode if isinstance(mamode, str) else "sma" + ddof = int(ddof) if ddof >= 0 and ddof < length else 1 + close = verify_series(close, length) offset = get_offset(offset) + if close is None: return + # Calculate Result - standard_deviation = stdev(close=close, length=length) + standard_deviation = stdev(close=close, length=length, ddof=ddof) deviations = std * standard_deviation mid = ma(mamode, close, length=length, **kwargs) - lower = mid - deviations upper = mid + deviations @@ -74,11 +76,11 @@ Sources: Calculation: Default Inputs: - length=20, std=2 + length=5, std=2, mamode="sma", ddof=0 EMA = Exponential Moving Average SMA = Simple Moving Average STDEV = Standard Deviation - stdev = STDEV(close, length) + stdev = STDEV(close, length, ddof) if "ema": MID = EMA(close, length) else: @@ -91,9 +93,10 @@ Calculation: Args: close (pd.Series): Series of 'close's - length (int): The short period. Default: 20 + length (int): The short period. Default: 5 std (int): The long period. Default: 2 - mamode (str): Two options: "sma" or "ema". Default: "ema" + mamode (str): Two options: "sma" or "ema". Default: "sma" + ddof (int): Degrees of Freedom to use. Default: 0 offset (int): How many periods to offset the result. Default: 0 Kwargs: diff --git a/pandas_ta/volatility/donchian.py b/pandas_ta/volatility/donchian.py index 790a75f..a84712c 100644 --- a/pandas_ta/volatility/donchian.py +++ b/pandas_ta/volatility/donchian.py @@ -6,14 +6,17 @@ from pandas_ta.utils import get_offset, verify_series def donchian(high, low, lower_length=None, upper_length=None, offset=None, **kwargs): """Indicator: Donchian Channels (DC)""" # Validate arguments - high = verify_series(high) - low = verify_series(low) lower_length = int(lower_length) if lower_length and lower_length > 0 else 20 upper_length = int(upper_length) if upper_length and upper_length > 0 else 20 lower_min_periods = int(kwargs["lower_min_periods"]) if "lower_min_periods" in kwargs and kwargs["lower_min_periods"] is not None else lower_length upper_min_periods = int(kwargs["upper_min_periods"]) if "upper_min_periods" in kwargs and kwargs["upper_min_periods"] is not None else upper_length + _length = max(lower_length, lower_min_periods, upper_length, upper_min_periods) + high = verify_series(high, _length) + low = verify_series(low, _length) offset = get_offset(offset) + if high is None or low is None: return + # Calculate Result lower = low.rolling(lower_length, min_periods=lower_min_periods).min() upper = high.rolling(upper_length, min_periods=upper_min_periods).max() diff --git a/pandas_ta/volatility/hwc.py b/pandas_ta/volatility/hwc.py new file mode 100644 index 0000000..e531aae --- /dev/null +++ b/pandas_ta/volatility/hwc.py @@ -0,0 +1,153 @@ +# -*- coding: utf-8 -*- +from numpy import sqrt as npSqrt +from pandas import DataFrame, Series +from pandas_ta.utils import get_offset, verify_series + + +def hwc(close, na=None, nb=None, nc=None, nd=None, scalar=None, channel_eval=None, offset=None, **kwargs): + """Indicator: Holt-Winter Channel""" + # Validate Arguments + na = float(na) if na and na > 0 else 0.2 + nb = float(nb) if nb and nb > 0 else 0.1 + nc = float(nc) if nc and nc > 0 else 0.1 + nd = float(nd) if nd and nd > 0 else 0.1 + scalar = float(scalar) if scalar and scalar > 0 else 1 + channel_eval = bool(channel_eval) if channel_eval and channel_eval else False + close = verify_series(close) + offset = get_offset(offset) + + # Calculate Result + last_a = last_v = last_var = 0 + last_f = last_price = last_result = close[0] + lower, result, upper = [], [], [] + chan_pct_width, chan_width = [], [] + + m = close.size + for i in range(m): + F = (1.0 - na) * (last_f + last_v + 0.5 * last_a) + na * close[i] + V = (1.0 - nb) * (last_v + last_a) + nb * (F - last_f) + A = (1.0 - nc) * last_a + nc * (V - last_v) + result.append((F + V + 0.5 * A)) + + var = (1.0 - nd) * last_var + nd * (last_price - last_result) * (last_price - last_result) + stddev = npSqrt(last_var) + upper.append(result[i] + scalar * stddev) + lower.append(result[i] - scalar * stddev) + + if channel_eval: + # channel width + chan_width.append(upper[i] - lower[i]) + # channel percentage price position + chan_pct_width.append((close[i] - lower[i]) / (upper[i] - lower[i])) + # print('channel_eval (width|percentageWidth):', chan_width[i], chan_pct_width[i]) + + # update values + last_price = close[i] + last_a = A + last_f = F + last_v = V + last_var = var + last_result = result[i] + + # Aggregate + hwc = Series(result, index=close.index) + hwc_upper = Series(upper, index=close.index) + hwc_lower = Series(lower, index=close.index) + if channel_eval: + hwc_width = Series(chan_width, index=close.index) + hwc_pctwidth = Series(chan_pct_width, index=close.index) + + # Offset + if offset != 0: + hwc = hwc.shift(offset) + hwc_upper = hwc_upper.shift(offset) + hwc_lower = hwc_lower.shift(offset) + if channel_eval: + hwc_width = hwc_width.shift(offset) + hwc_pctwidth = hwc_pctwidth.shift(offset) + + # Handle fills + if "fillna" in kwargs: + hwc.fillna(kwargs["fillna"], inplace=True) + hwc_upper.fillna(kwargs["fillna"], inplace=True) + hwc_lower.fillna(kwargs["fillna"], inplace=True) + if channel_eval: + hwc_width.fillna(kwargs["fillna"], inplace=True) + hwc_pctwidth.fillna(kwargs["fillna"], inplace=True) + + if "fill_method" in kwargs: + hwc.fillna(method=kwargs["fill_method"], inplace=True) + hwc_upper.fillna(method=kwargs["fill_method"], inplace=True) + hwc_lower.fillna(method=kwargs["fill_method"], inplace=True) + if channel_eval: + hwc_width.fillna(method=kwargs["fill_method"], inplace=True) + hwc_pctwidth.fillna(method=kwargs["fill_method"], inplace=True) + + # Name and Categorize it + # suffix = f'{str(na).replace(".", "")}-{str(nb).replace(".", "")}-{str(nc).replace(".", "")}' + hwc.name = 'HW-MID' + hwc_upper.name = "HW-UPPER" + hwc_lower.name = "HW-LOWER" + hwc.category = hwc_upper.category = hwc_lower.category = "volatility" + if channel_eval: + hwc_width.name = 'HW-WIDTH' + hwc_pctwidth.name = 'HW-PCTW' + + # Prepare DataFrame to return + if channel_eval: + data = {hwc.name: hwc, hwc_upper.name: hwc_upper, hwc_lower.name: hwc_lower, + hwc_width.name: hwc_width, hwc_pctwidth.name: hwc_pctwidth} + df = DataFrame(data) + df.name = "hwc" + df.category = hwc.category + else: + data = {hwc.name: hwc, hwc_upper.name: hwc_upper, hwc_lower.name: hwc_lower} + df = DataFrame(data) + df.name = "hwc" + df.category = hwc.category + + return df + + + +hwc.__doc__ = \ +"""HWC (Holt-Winter Channel) + +Channel indicator HWC (Holt-Winters Channel) based on HWMA - a three-parameter +moving average calculated by the method of Holt-Winters. + +This version has been implemented for Pandas TA by rengel8 based on a +publication for MetaTrader 5 extended by width and percentage price position +against width of channel. + +Sources: + https://www.mql5.com/en/code/20857 + +Calculation: + HWMA[i] = F[i] + V[i] + 0.5 * A[i] + where.. + F[i] = (1-na) * (F[i-1] + V[i-1] + 0.5 * A[i-1]) + na * Price[i] + V[i] = (1-nb) * (V[i-1] + A[i-1]) + nb * (F[i] - F[i-1]) + A[i] = (1-nc) * A[i-1] + nc * (V[i] - V[i-1]) + + Top = HWMA + Multiplier * StDt + Bottom = HWMA - Multiplier * StDt + where.. + StDt[i] = Sqrt(Var[i-1]) + Var[i] = (1-d) * Var[i-1] + nD * (Price[i-1] - HWMA[i-1]) * (Price[i-1] - HWMA[i-1]) + +Args: + na - parameter of the equation that describes a smoothed series (from 0 to 1) + nb - parameter of the equation to assess the trend (from 0 to 1) + nc - parameter of the equation to assess seasonality (from 0 to 1) + nd - parameter of the channel equation (from 0 to 1) + scaler - multiplier for the width of the channel calculated + channel_eval - boolean to return width and percentage price position against price + close (pd.Series): Series of 'close's + +Kwargs: + fillna (value, optional): pd.DataFrame.fillna(value) + fill_method (value, optional): Type of fill method +Returns: + pd.DataFrame: HW-MID, HW-UPPER, HW-LOWER columns. +""" diff --git a/pandas_ta/volatility/kc.py b/pandas_ta/volatility/kc.py index 12c72de..31a8115 100644 --- a/pandas_ta/volatility/kc.py +++ b/pandas_ta/volatility/kc.py @@ -8,14 +8,16 @@ from pandas_ta.utils import get_offset, high_low_range, verify_series def kc(high, low, close, length=None, scalar=None, mamode=None, offset=None, **kwargs): """Indicator: Keltner Channels (KC)""" # Validate arguments - high = verify_series(high) - low = verify_series(low) - close = verify_series(close) length = int(length) if length and length > 0 else 20 scalar = float(scalar) if scalar and scalar > 0 else 2 mamode = mamode if isinstance(mamode, str) else "ema" + high = verify_series(high, length) + low = verify_series(low, length) + close = verify_series(close, length) offset = get_offset(offset) + if high is None or low is None or close is None: return + # Calculate Result use_tr = kwargs.pop("tr", True) if use_tr: diff --git a/pandas_ta/volatility/massi.py b/pandas_ta/volatility/massi.py index 053be85..3604cbb 100644 --- a/pandas_ta/volatility/massi.py +++ b/pandas_ta/volatility/massi.py @@ -6,17 +6,20 @@ from pandas_ta.utils import get_offset, non_zero_range, verify_series def massi(high, low, fast=None, slow=None, offset=None, **kwargs): """Indicator: Mass Index (MASSI)""" # Validate arguments - high = verify_series(high) - low = verify_series(low) - high_low_range = non_zero_range(high, low) fast = int(fast) if fast and fast > 0 else 9 slow = int(slow) if slow and slow > 0 else 25 if slow < fast: fast, slow = slow, fast - min_periods = int(kwargs["min_periods"]) if "min_periods" in kwargs and kwargs["min_periods"] is not None else fast + _length = max(fast, slow) + high = verify_series(high, _length) + low = verify_series(low, _length) offset = get_offset(offset) + if "length" in kwargs: kwargs.pop("length") + + if high is None or low is None: return # Calculate Result + high_low_range = non_zero_range(high, low) hl_ema1 = ema(close=high_low_range, length=fast, **kwargs) hl_ema2 = ema(close=hl_ema1, length=fast, **kwargs) @@ -63,9 +66,9 @@ Calculation: Args: high (pd.Series): Series of 'high's low (pd.Series): Series of 'low's - fast (int): The short period. Default: 9 - slow (int): The long period. Default: 25 - offset (int): How many periods to offset the result. Default: 0 + fast (int): The short period. Default: 9 + slow (int): The long period. Default: 25 + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/volatility/natr.py b/pandas_ta/volatility/natr.py index a5eca55..ae67aaf 100644 --- a/pandas_ta/volatility/natr.py +++ b/pandas_ta/volatility/natr.py @@ -6,15 +6,17 @@ from pandas_ta.utils import get_drift, get_offset, verify_series def natr(high, low, close, length=None, mamode=None, scalar=None, drift=None, offset=None, **kwargs): """Indicator: Normalized Average True Range (NATR)""" # Validate arguments - high = verify_series(high) - low = verify_series(low) - close = verify_series(close) length = int(length) if length and length > 0 else 14 mamode = mamode if isinstance(mamode, str) else "ema" scalar = float(scalar) if scalar else 100 + high = verify_series(high, length) + low = verify_series(low, length) + close = verify_series(close, length) drift = get_drift(drift) offset = get_offset(offset) + if high is None or low is None or close is None: return + # Calculate Result natr = scalar / close natr *= atr(high=high, low=low, close=close, length=length, mamode=mamode, drift=drift, offset=offset, **kwargs) @@ -39,8 +41,7 @@ def natr(high, low, close, length=None, mamode=None, scalar=None, drift=None, of natr.__doc__ = \ """Normalized Average True Range (NATR) -Normalized Average True Range attempt to normalize the average -true range. +Normalized Average True Range attempt to normalize the average true range. Sources: https://www.tradingtechnologies.com/help/x-study/technical-indicator-definitions/normalized-average-true-range-natr/ @@ -55,9 +56,9 @@ Args: high (pd.Series): Series of 'high's low (pd.Series): Series of 'low's close (pd.Series): Series of 'close's - length (int): The short period. Default: 20 - scalar (float): How much to magnify. Default: 100 - offset (int): How many periods to offset the result. Default: 0 + length (int): The short period. Default: 20 + scalar (float): How much to magnify. Default: 100 + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/volatility/pdist.py b/pandas_ta/volatility/pdist.py index 3f3422b..1a75439 100644 --- a/pandas_ta/volatility/pdist.py +++ b/pandas_ta/volatility/pdist.py @@ -47,8 +47,8 @@ Args: high (pd.Series): Series of 'high's low (pd.Series): Series of 'low's close (pd.Series): Series of 'close's - drift (int): The difference period. Default: 1 - offset (int): How many periods to offset the result. Default: 0 + drift (int): The difference period. Default: 1 + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/volatility/rvi.py b/pandas_ta/volatility/rvi.py index bdeed7d..29225c2 100644 --- a/pandas_ta/volatility/rvi.py +++ b/pandas_ta/volatility/rvi.py @@ -1,22 +1,24 @@ # -*- coding: utf-8 -*- from pandas_ta.overlap import ma from pandas_ta.statistics import stdev -from pandas_ta.utils import get_drift, get_offset, non_zero_range +from pandas_ta.utils import get_drift, get_offset from pandas_ta.utils import unsigned_differences, verify_series def rvi(close, high=None, low=None, length=None, scalar=None, refined=None, thirds=None, mamode=None, drift=None, offset=None, **kwargs): """Indicator: Relative Volatility Index (RVI)""" # Validate arguments - close = verify_series(close) length = int(length) if length and length > 0 else 14 scalar = float(scalar) if scalar and scalar > 0 else 100 refined = False if refined is None else refined thirds = False if thirds is None else thirds mamode = mamode if isinstance(mamode, str) else "ema" + close = verify_series(close, length) drift = get_drift(drift) offset = get_offset(offset) + if close is None: return + if refined or thirds: high = verify_series(high) low = verify_series(low) @@ -72,10 +74,9 @@ def rvi(close, high=None, low=None, length=None, scalar=None, refined=None, thir rvi.__doc__ = \ """Relative Volatility Index (RVI) -The Relative Volatility Index (RVI) was created in 1993 and -revised in 1995. Instead of adding up price changes like RSI -based on price direction, the RVI adds up standard deviations -based on price direction. +The Relative Volatility Index (RVI) was created in 1993 and revised in 1995. +Instead of adding up price changes like RSI based on price direction, the RVI +adds up standard deviations based on price direction. Sources: https://www.tradingview.com/wiki/Keltner_Channels_(KC) @@ -99,12 +100,12 @@ Args: low (pd.Series): Series of 'low's close (pd.Series): Series of 'close's length (int): The short period. Default: 14 - scalar (float): A positive float to scale the bands. Default: 100 + scalar (float): A positive float to scale the bands. Default: 100 mamode (str): Options: 'sma' or 'ema'. Default: 'sma' refined (bool): Use 'refined' calculation which is the average of RVI(high) and RVI(low) instead of RVI(close). Default: False thirds (bool): Average of high, low and close. Default: False - offset (int): How many periods to offset the result. Default: 0 + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/volatility/thermo.py b/pandas_ta/volatility/thermo.py index c4221a2..3c0617c 100644 --- a/pandas_ta/volatility/thermo.py +++ b/pandas_ta/volatility/thermo.py @@ -1,5 +1,4 @@ # -*- coding: utf-8 -*- -import numpy as np from pandas import DataFrame from pandas_ta.overlap import ma from pandas_ta.utils import get_offset, verify_series, get_drift @@ -8,16 +7,18 @@ from pandas_ta.utils import get_offset, verify_series, get_drift def thermo(high, low, length=None, long=None, short=None, mamode=None, drift=None, offset=None, **kwargs): """Indicator: Elders Thermometer (THERMO)""" # Validate arguments - high = verify_series(high) - low = verify_series(low) length = int(length) if length and length > 0 else 20 long = float(long) if long and long > 0 else 2 short = float(short) if short and short > 0 else 0.5 mamode = mamode if isinstance(mamode, str) else "ema" + high = verify_series(high, length) + low = verify_series(low, length) drift = get_drift(drift) offset = get_offset(offset) asint = kwargs.pop("asint", True) + if high is None or low is None: return + # Calculate Result thermoL = (low.shift(drift) - low).abs() thermoH = (high - high.shift(drift)).abs() @@ -34,7 +35,7 @@ def thermo(high, low, length=None, long=None, short=None, mamode=None, drift=Non # Binary output, useful for signals if asint: - thermo_long = thermo_long.astype(int) + thermo_long = thermo_long.astype(int) thermo_short = thermo_short.astype(int) # Offset @@ -66,7 +67,12 @@ def thermo(high, low, length=None, long=None, short=None, mamode=None, drift=Non thermo.category = thermo_ma.category = thermo_long.category = thermo_short.category = "volatility" # Prepare Dataframe to return - data = {thermo.name: thermo, thermo_ma.name: thermo_ma, thermo_long.name: thermo_long, thermo_short.name: thermo_short} + data = { + thermo.name: thermo, + thermo_ma.name: thermo_ma, + thermo_long.name: thermo_long, + thermo_short.name: thermo_short + } df = DataFrame(data) df.name = f"THERMO{_props}" df.category = thermo.category diff --git a/pandas_ta/volatility/true_range.py b/pandas_ta/volatility/true_range.py index 9567fd4..9e301cd 100644 --- a/pandas_ta/volatility/true_range.py +++ b/pandas_ta/volatility/true_range.py @@ -1,4 +1,5 @@ # -*- coding: utf-8 -*- +from numpy import NaN as npNaN from pandas import DataFrame from pandas_ta.utils import get_drift, get_offset, non_zero_range, verify_series @@ -9,15 +10,16 @@ def true_range(high, low, close, drift=None, offset=None, **kwargs): high = verify_series(high) low = verify_series(low) close = verify_series(close) - high_low_range = non_zero_range(high, low) drift = get_drift(drift) offset = get_offset(offset) # Calculate Result + high_low_range = non_zero_range(high, low) prev_close = close.shift(drift) ranges = [high_low_range, high - prev_close, prev_close - low] true_range = DataFrame(ranges).T true_range = true_range.abs().max(axis=1) + true_range.iloc[:drift] = npNaN # Offset if offset != 0: @@ -56,8 +58,8 @@ Args: high (pd.Series): Series of 'high's low (pd.Series): Series of 'low's close (pd.Series): Series of 'close's - drift (int): The shift period. Default: 1 - offset (int): How many periods to offset the result. Default: 0 + drift (int): The shift period. Default: 1 + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/volatility/ui.py b/pandas_ta/volatility/ui.py index 0e4e45a..712d680 100644 --- a/pandas_ta/volatility/ui.py +++ b/pandas_ta/volatility/ui.py @@ -7,11 +7,13 @@ from pandas_ta.utils import get_offset, non_zero_range, verify_series def ui(close, length=None, scalar=None, offset=None, **kwargs): """Indicator: Ulcer Index (UI)""" # Validate arguments - close = verify_series(close) length = int(length) if length and length > 0 else 14 scalar = float(scalar) if scalar and scalar > 0 else 100 + close = verify_series(close, length) offset = get_offset(offset) + if close is None: return + # Calculate Result highest_close = close.rolling(length).max() downside = scalar * (close - highest_close) diff --git a/pandas_ta/volume/ad.py b/pandas_ta/volume/ad.py index 584271f..44af86f 100644 --- a/pandas_ta/volume/ad.py +++ b/pandas_ta/volume/ad.py @@ -9,7 +9,6 @@ def ad(high, low, close, volume, open_=None, offset=None, **kwargs): low = verify_series(low) close = verify_series(close) volume = verify_series(volume) - high_low_range = non_zero_range(high, low) offset = get_offset(offset) # Calculate Result @@ -19,6 +18,7 @@ def ad(high, low, close, volume, open_=None, offset=None, **kwargs): else: ad = 2 * close - (high + low) # AD with High, Low, Close + high_low_range = non_zero_range(high, low) ad *= volume / high_low_range ad = ad.cumsum() @@ -65,7 +65,7 @@ Args: close (pd.Series): Series of 'close's volume (pd.Series): Series of 'volume's open (pd.Series): Series of 'open's - offset (int): How many periods to offset the result. Default: 0 + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/volume/adosc.py b/pandas_ta/volume/adosc.py index 3553a24..a534607 100644 --- a/pandas_ta/volume/adosc.py +++ b/pandas_ta/volume/adosc.py @@ -7,13 +7,17 @@ from pandas_ta.utils import get_offset, verify_series def adosc(high, low, close, volume, open_=None, fast=None, slow=None, offset=None, **kwargs): """Indicator: Accumulation/Distribution Oscillator""" # Validate Arguments - high = verify_series(high) - low = verify_series(low) - close = verify_series(close) - volume = verify_series(volume) fast = int(fast) if fast and fast > 0 else 3 slow = int(slow) if slow and slow > 0 else 10 + _length = max(fast, slow) + high = verify_series(high, _length) + low = verify_series(low, _length) + close = verify_series(close, _length) + volume = verify_series(volume, _length) offset = get_offset(offset) + if "length" in kwargs: kwargs.pop("length") + + if high is None or low is None or close is None or volume is None: return # Calculate Result ad_ = ad(high=high, low=low, close=close, volume=volume, open_=open_) @@ -63,9 +67,9 @@ Args: close (pd.Series): Series of 'close's open (pd.Series): Series of 'open's volume (pd.Series): Series of 'volume's - fast (int): The short period. Default: 12 - slow (int): The long period. Default: 26 - offset (int): How many periods to offset the result. Default: 0 + fast (int): The short period. Default: 12 + slow (int): The long period. Default: 26 + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/volume/aobv.py b/pandas_ta/volume/aobv.py index 88328b2..a2c0699 100644 --- a/pandas_ta/volume/aobv.py +++ b/pandas_ta/volume/aobv.py @@ -9,9 +9,6 @@ from pandas_ta.utils import get_offset, verify_series def aobv(close, volume, fast=None, slow=None, mamode=None, max_lookback=None, min_lookback=None, offset=None, **kwargs): """Indicator: Archer On Balance Volume (AOBV)""" # Validate arguments - close = verify_series(close) - volume = verify_series(volume) - offset = get_offset(offset) fast = int(fast) if fast and fast > 0 else 4 slow = int(slow) if slow and slow > 0 else 12 max_lookback = int(max_lookback) if max_lookback and max_lookback > 0 else 2 @@ -19,8 +16,15 @@ def aobv(close, volume, fast=None, slow=None, mamode=None, max_lookback=None, mi if slow < fast: fast, slow = slow, fast mamode = mamode if isinstance(mamode, str) else "ema" + _length = max(fast, slow, max_lookback, min_lookback) + close = verify_series(close, _length) + volume = verify_series(volume, _length) + offset = get_offset(offset) + if "length" in kwargs: kwargs.pop("length") run_length = kwargs.pop("run_length", 2) + if close is None or volume is None: return + # Calculate Result obv_ = obv(close=close, volume=volume, **kwargs) maf = ma(mamode, obv_, length=fast, **kwargs) diff --git a/pandas_ta/volume/cmf.py b/pandas_ta/volume/cmf.py index d5c1b08..58903d8 100644 --- a/pandas_ta/volume/cmf.py +++ b/pandas_ta/volume/cmf.py @@ -5,15 +5,17 @@ from pandas_ta.utils import get_offset, non_zero_range, verify_series def cmf(high, low, close, volume, open_=None, length=None, offset=None, **kwargs): """Indicator: Chaikin Money Flow (CMF)""" # Validate Arguments - high = verify_series(high) - low = verify_series(low) - close = verify_series(close) - volume = verify_series(volume) - high_low_range = non_zero_range(high, low) length = int(length) if length and length > 0 else 20 min_periods = int(kwargs["min_periods"]) if "min_periods" in kwargs and kwargs["min_periods"] is not None else length + _length = max(length, min_periods) + high = verify_series(high, _length) + low = verify_series(low, _length) + close = verify_series(close, _length) + volume = verify_series(volume, _length) offset = get_offset(offset) + if high is None or low is None or close is None or volume is None: return + # Calculate Result if open_ is not None: open_ = verify_series(open_) @@ -21,7 +23,7 @@ def cmf(high, low, close, volume, open_=None, length=None, offset=None, **kwargs else: ad = 2 * close - (high + low) # AD with High, Low, Close - ad *= volume / high_low_range + ad *= volume / non_zero_range(high, low) cmf = ad.rolling(length, min_periods=min_periods).sum() cmf /= volume.rolling(length, min_periods=min_periods).sum() @@ -70,8 +72,8 @@ Args: close (pd.Series): Series of 'close's volume (pd.Series): Series of 'volume's open_ (pd.Series): Series of 'open's. Default: None - length (int): The short period. Default: 20 - offset (int): How many periods to offset the result. Default: 0 + length (int): The short period. Default: 20 + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/volume/efi.py b/pandas_ta/volume/efi.py index fcc3f92..6364345 100644 --- a/pandas_ta/volume/efi.py +++ b/pandas_ta/volume/efi.py @@ -6,13 +6,15 @@ from pandas_ta.utils import get_drift, get_offset, verify_series def efi(close, volume, length=None, drift=None, mamode=None, offset=None, **kwargs): """Indicator: Elder's Force Index (EFI)""" # Validate arguments - close = verify_series(close) - volume = verify_series(volume) length = int(length) if length and length > 0 else 13 - drift = get_drift(drift) mamode = mamode if isinstance(mamode, str) else "ema" + close = verify_series(close, length) + volume = verify_series(volume, length) + drift = get_drift(drift) offset = get_offset(offset) + if close is None or volume is None: return + # Calculate Result pv_diff = close.diff(drift) * volume efi = ma(mamode, pv_diff, length=length) @@ -59,10 +61,10 @@ Calculation: Args: close (pd.Series): Series of 'close's volume (pd.Series): Series of 'volume's - length (int): The short period. Default: 13 - drift (int): The diff period. Default: 1 - mamode (str): Two options: None or "sma". Default: None - offset (int): How many periods to offset the result. Default: 0 + length (int): The short period. Default: 13 + drift (int): The diff period. Default: 1 + mamode (str): Two options: None or "sma". Default: None + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/volume/eom.py b/pandas_ta/volume/eom.py index c32cb59..7f936f2 100644 --- a/pandas_ta/volume/eom.py +++ b/pandas_ta/volume/eom.py @@ -6,15 +6,17 @@ from pandas_ta.utils import get_drift, get_offset, non_zero_range, verify_series def eom(high, low, close, volume, length=None, divisor=None, drift=None, offset=None, **kwargs): """Indicator: Ease of Movement (EOM)""" # Validate arguments - high = verify_series(high) - low = verify_series(low) - close = verify_series(close) - volume = verify_series(volume) length = int(length) if length and length > 0 else 14 divisor = divisor if divisor and divisor > 0 else 100000000 + high = verify_series(high, length) + low = verify_series(low, length) + close = verify_series(close, length) + volume = verify_series(volume, length) drift = get_drift(drift) offset = get_offset(offset) + if high is None or low is None or close is None or volume is None: return + # Calculate Result high_low_range = non_zero_range(high, low) distance = hl2(high=high, low=low) @@ -67,9 +69,9 @@ Args: low (pd.Series): Series of 'low's close (pd.Series): Series of 'close's volume (pd.Series): Series of 'volume's - length (int): The short period. Default: 14 - drift (int): The diff period. Default: 1 - offset (int): How many periods to offset the result. Default: 0 + length (int): The short period. Default: 14 + drift (int): The diff period. Default: 1 + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/volume/mfi.py b/pandas_ta/volume/mfi.py index e803e2d..8696186 100644 --- a/pandas_ta/volume/mfi.py +++ b/pandas_ta/volume/mfi.py @@ -7,14 +7,16 @@ from pandas_ta.utils import get_drift, get_offset, verify_series def mfi(high, low, close, volume, length=None, drift=None, offset=None, **kwargs): """Indicator: Money Flow Index (MFI)""" # Validate arguments - high = verify_series(high) - low = verify_series(low) - close = verify_series(close) - volume = verify_series(volume) length = int(length) if length and length > 0 else 14 + high = verify_series(high, length) + low = verify_series(low, length) + close = verify_series(close, length) + volume = verify_series(volume, length) drift = get_drift(drift) offset = get_offset(offset) + if high is None or low is None or close is None or volume is None: return + # Calculate Result typical_price = hlc3(high=high, low=low, close=close) raw_money_flow = typical_price * volume @@ -76,9 +78,9 @@ Args: low (pd.Series): Series of 'low's close (pd.Series): Series of 'close's volume (pd.Series): Series of 'volume's - length (int): The sum period. Default: 14 - drift (int): The difference period. Default: 1 - offset (int): How many periods to offset the result. Default: 0 + length (int): The sum period. Default: 14 + drift (int): The difference period. Default: 1 + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/volume/nvi.py b/pandas_ta/volume/nvi.py index 90723b6..fb08b31 100644 --- a/pandas_ta/volume/nvi.py +++ b/pandas_ta/volume/nvi.py @@ -6,13 +6,15 @@ from pandas_ta.utils import get_offset, signed_series, verify_series def nvi(close, volume, length=None, initial=None, offset=None, **kwargs): """Indicator: Negative Volume Index (NVI)""" # Validate arguments - close = verify_series(close) - volume = verify_series(volume) length = int(length) if length and length > 0 else 1 - min_periods = int(kwargs["min_periods"]) if "min_periods" in kwargs and kwargs["min_periods"] is not None else length + # min_periods = int(kwargs["min_periods"]) if "min_periods" in kwargs and kwargs["min_periods"] is not None else length initial = int(initial) if initial and initial > 0 else 1000 + close = verify_series(close, length) + volume = verify_series(volume, length) offset = get_offset(offset) + if close is None or volume is None: return + # Calculate Result roc_ = roc(close=close, length=length) signed_volume = signed_series(volume, initial=1) @@ -63,9 +65,9 @@ Calculation: Args: close (pd.Series): Series of 'close's volume (pd.Series): Series of 'volume's - length (int): The short period. Default: 13 - initial (int): The short period. Default: 1000 - offset (int): How many periods to offset the result. Default: 0 + length (int): The short period. Default: 13 + initial (int): The short period. Default: 1000 + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/volume/obv.py b/pandas_ta/volume/obv.py index bd185e8..81b332c 100644 --- a/pandas_ta/volume/obv.py +++ b/pandas_ta/volume/obv.py @@ -48,7 +48,7 @@ Calculation: Args: close (pd.Series): Series of 'close's volume (pd.Series): Series of 'volume's - offset (int): How many periods to offset the result. Default: 0 + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/volume/pvi.py b/pandas_ta/volume/pvi.py index 16475a7..8ab2da9 100644 --- a/pandas_ta/volume/pvi.py +++ b/pandas_ta/volume/pvi.py @@ -6,13 +6,15 @@ from pandas_ta.utils import get_offset, signed_series, verify_series def pvi(close, volume, length=None, initial=None, offset=None, **kwargs): """Indicator: Positive Volume Index (PVI)""" # Validate arguments - close = verify_series(close) - volume = verify_series(volume) length = int(length) if length and length > 0 else 1 - min_periods = int(kwargs["min_periods"]) if "min_periods" in kwargs and kwargs["min_periods"] is not None else length + # min_periods = int(kwargs["min_periods"]) if "min_periods" in kwargs and kwargs["min_periods"] is not None else length initial = int(initial) if initial and initial > 0 else 1000 + close = verify_series(close, length) + volume = verify_series(volume, length) offset = get_offset(offset) + if close is None or volume is None: return + # Calculate Result roc_ = roc(close=close, length=length) signed_volume = signed_series(volume, initial=1) @@ -42,7 +44,8 @@ pvi.__doc__ = \ """Positive Volume Index (PVI) The Positive Volume Index is a cumulative indicator that uses volume change in -an attempt to identify where smart money is active. Used in conjunction with NVI. +an attempt to identify where smart money is active. +Used in conjunction with NVI. Sources: https://www.investopedia.com/terms/p/pvi.asp @@ -62,9 +65,9 @@ Calculation: Args: close (pd.Series): Series of 'close's volume (pd.Series): Series of 'volume's - length (int): The short period. Default: 13 - initial (int): The short period. Default: 1000 - offset (int): How many periods to offset the result. Default: 0 + length (int): The short period. Default: 13 + initial (int): The short period. Default: 1000 + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/volume/pvol.py b/pandas_ta/volume/pvol.py index 485d1e5..8168943 100644 --- a/pandas_ta/volume/pvol.py +++ b/pandas_ta/volume/pvol.py @@ -47,8 +47,8 @@ Calculation: Args: close (pd.Series): Series of 'close's volume (pd.Series): Series of 'volume's - signed (bool): Keeps the sign of the difference in 'close's. Default: True - offset (int): How many periods to offset the result. Default: 0 + signed (bool): Keeps the sign of the difference in 'close's. Default: True + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/volume/pvt.py b/pandas_ta/volume/pvt.py index 3990dac..c8650bc 100644 --- a/pandas_ta/volume/pvt.py +++ b/pandas_ta/volume/pvt.py @@ -51,8 +51,8 @@ Calculation: Args: close (pd.Series): Series of 'close's volume (pd.Series): Series of 'volume's - drift (int): The diff period. Default: 1 - offset (int): How many periods to offset the result. Default: 0 + drift (int): The diff period. Default: 1 + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/pandas_ta/volume/vp.py b/pandas_ta/volume/vp.py index 73ced59..97e288f 100644 --- a/pandas_ta/volume/vp.py +++ b/pandas_ta/volume/vp.py @@ -7,11 +7,13 @@ from pandas_ta.utils import signed_series, verify_series def vp(close, volume, width=None, **kwargs): """Indicator: Volume Profile (VP)""" # Validate arguments - close = verify_series(close) - volume = verify_series(volume) width = int(width) if width and width > 0 else 10 + close = verify_series(close, width) + volume = verify_series(volume, width) sort_close = kwargs.pop("sort_close", False) + if close is None or volume is None: return + # Setup signed_volume = signed_series(volume, initial=1) pos_volume = signed_volume[signed_volume > 0] * volume @@ -63,7 +65,8 @@ def vp(close, volume, width=None, **kwargs): vp.__doc__ = \ """Volume Profile (VP) -Calculates the Volume Profile by slicing price into ranges. Note: Value Area is not calculated. +Calculates the Volume Profile by slicing price into ranges. +Note: Value Area is not calculated. Sources: https://stockcharts.com/school/doku.php?id=chart_school:technical_indicators:volume_by_price @@ -89,7 +92,8 @@ Args: Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) fill_method (value, optional): Type of fill method - sort_close (value, optional): Whether to sort by close before splitting into ranges. Default: False + sort_close (value, optional): Whether to sort by close before splitting + into ranges. Default: False Returns: pd.DataFrame: New feature generated. diff --git a/setup.py b/setup.py index ac8c755..946f8c2 100644 --- a/setup.py +++ b/setup.py @@ -1,13 +1,14 @@ # -*- coding: utf-8 -*- from distutils.core import setup -long_description = "An easy to use Python 3 Pandas Extension with 115+ Technical Analysis Indicators. Can be called from a Pandas DataFrame or standalone like TA-Lib. Correlation tested with TA-Lib." +long_description = "An easy to use Python 3 Pandas Extension with 130+ Technical Analysis Indicators. Can be called from a Pandas DataFrame or standalone like TA-Lib. Correlation tested with TA-Lib." setup( name="pandas_ta", packages=[ "pandas_ta", "pandas_ta.candles", + "pandas_ta.cycles", "pandas_ta.momentum", "pandas_ta.overlap", "pandas_ta.performance", @@ -17,7 +18,7 @@ setup( "pandas_ta.volatility", "pandas_ta.volume" ], - version=".".join(("0", "2", "42b")), + version=".".join(("0", "2", "62b")), description=long_description, long_description=long_description, author="Kevin Johnson", @@ -34,6 +35,7 @@ setup( "Programming Language :: Python :: 3.6", "Programming Language :: Python :: 3.7", "Programming Language :: Python :: 3.8", + "Programming Language :: Python :: 3.9", "Operating System :: OS Independent", "License :: OSI Approved :: MIT License", "Natural Language :: English", diff --git a/tests/test_ext_indicator_cycles.py b/tests/test_ext_indicator_cycles.py new file mode 100644 index 0000000..f71c2aa --- /dev/null +++ b/tests/test_ext_indicator_cycles.py @@ -0,0 +1,25 @@ +from pandas.core.series import Series +from .config import sample_data +from .context import pandas_ta + +from unittest import TestCase +from pandas import DataFrame + + +class TestCylesExtension(TestCase): + @classmethod + def setUpClass(cls): + cls.data = sample_data + + @classmethod + def tearDownClass(cls): + del cls.data + + def setUp(self): pass + def tearDown(self): pass + + + def test_ebsw_ext(self): + self.data.ta.ebsw(append=True) + self.assertIsInstance(self.data, DataFrame) + self.assertEqual(self.data.columns[-1], "EBSW_40_10") diff --git a/tests/test_ext_indicator_momentum.py b/tests/test_ext_indicator_momentum.py index c4d6900..d5b5c95 100644 --- a/tests/test_ext_indicator_momentum.py +++ b/tests/test_ext_indicator_momentum.py @@ -207,6 +207,15 @@ class TestMomentumExtension(TestCase): self.assertIsInstance(self.data, DataFrame) self.assertEqual(list(self.data.columns[-2:]), ["STOCHRSIk_14_14_3_3", "STOCHRSId_14_14_3_3"]) + def test_td_seq_ext(self): + self.data.ta.td_seq(show_all=False, append=True) + self.assertIsInstance(self.data, DataFrame) + self.assertEqual(list(self.data.columns[-2:]), ["TD_SEQ_UP", "TD_SEQ_DN"]) + + self.data.ta.td_seq(show_all=True, append=True) + self.assertIsInstance(self.data, DataFrame) + self.assertEqual(list(self.data.columns[-2:]), ["TD_SEQ_UPa", "TD_SEQ_DNa"]) + def test_trix_ext(self): self.data.ta.trix(append=True) self.assertIsInstance(self.data, DataFrame) diff --git a/tests/test_ext_indicator_overlap_ext.py b/tests/test_ext_indicator_overlap_ext.py index 9744621..f56ba41 100644 --- a/tests/test_ext_indicator_overlap_ext.py +++ b/tests/test_ext_indicator_overlap_ext.py @@ -18,6 +18,11 @@ class TestOverlapExtension(TestCase): def tearDown(self): pass + def test_alma_ext(self): + self.data.ta.alma(append=True) + self.assertIsInstance(self.data, DataFrame) + self.assertEqual(self.data.columns[-1], "ALMA_10_6.0_0.85") + def test_dema_ext(self): self.data.ta.dema(append=True) self.assertIsInstance(self.data, DataFrame) @@ -53,6 +58,11 @@ class TestOverlapExtension(TestCase): self.assertIsInstance(self.data, DataFrame) self.assertEqual(self.data.columns[-1], "HMA_10") + def test_hwma_ext(self): + self.data.ta.hwma(append=True) + self.assertIsInstance(self.data, DataFrame) + self.assertEqual(self.data.columns[-1], "HWMA_0.2_0.1_0.1") + def test_kama_ext(self): self.data.ta.kama(append=True) self.assertIsInstance(self.data, DataFrame) diff --git a/tests/test_indicator_cycles.py b/tests/test_indicator_cycles.py new file mode 100644 index 0000000..c4ae54d --- /dev/null +++ b/tests/test_indicator_cycles.py @@ -0,0 +1,40 @@ +from .config import error_analysis, sample_data, CORRELATION, CORRELATION_THRESHOLD, VERBOSE +from .context import pandas_ta + +from unittest import TestCase, skip +import pandas.testing as pdt +from pandas import DataFrame, Series + +import talib as tal + + +class TestCycles(TestCase): + @classmethod + def setUpClass(cls): + cls.data = sample_data + cls.data.columns = cls.data.columns.str.lower() + cls.open = cls.data["open"] + cls.high = cls.data["high"] + cls.low = cls.data["low"] + cls.close = cls.data["close"] + if "volume" in cls.data.columns: + cls.volume = cls.data["volume"] + + @classmethod + def tearDownClass(cls): + del cls.open + del cls.high + del cls.low + del cls.close + if hasattr(cls, "volume"): + del cls.volume + del cls.data + + def setUp(self): pass + def tearDown(self): pass + + + def test_ebsw(self): + result = pandas_ta.ebsw(self.close) + self.assertIsInstance(result, Series) + self.assertEqual(result.name, "EBSW_40_10") diff --git a/tests/test_indicator_momentum.py b/tests/test_indicator_momentum.py index 5aa9a84..7589ac3 100644 --- a/tests/test_indicator_momentum.py +++ b/tests/test_indicator_momentum.py @@ -362,6 +362,11 @@ class TestMomentum(TestCase): self.assertIsInstance(result, DataFrame) self.assertEqual(result.name, "STOCHRSI_14_14_3_3") + def test_td_seq(self): + result = pandas_ta.td_seq(self.close) + self.assertIsInstance(result, DataFrame) + self.assertEqual(result.name, "TD_SEQ") + def test_trix(self): result = pandas_ta.trix(self.close) self.assertIsInstance(result, DataFrame) diff --git a/tests/test_indicator_overlap.py b/tests/test_indicator_overlap.py index 971aea6..b8bf9dc 100644 --- a/tests/test_indicator_overlap.py +++ b/tests/test_indicator_overlap.py @@ -34,6 +34,11 @@ class TestOverlap(TestCase): def tearDown(self): pass + def test_alma(self): + result = pandas_ta.alma(self.close)# , length=None, sigma=None, distribution_offset=) + self.assertIsInstance(result, Series) + self.assertEqual(result.name, "ALMA_10_6.0_0.85") + def test_dema(self): result = pandas_ta.dema(self.close) self.assertIsInstance(result, Series) @@ -99,6 +104,11 @@ class TestOverlap(TestCase): self.assertIsInstance(result, Series) self.assertEqual(result.name, "HMA_10") + def test_hwma(self): + result = pandas_ta.hwma(self.close) + self.assertIsInstance(result, Series) + self.assertEqual(result.name, "HWMA_0.2_0.1_0.1") + def test_kama(self): result = pandas_ta.kama(self.close) self.assertIsInstance(result, Series) diff --git a/tests/test_strategy.py b/tests/test_strategy.py index 3e50636..0efb262 100644 --- a/tests/test_strategy.py +++ b/tests/test_strategy.py @@ -67,6 +67,11 @@ class TestStrategyMethods(TestCase): self.category = "All" self.data.ta.strategy(verbose=verbose, timed=strategy_timed) + def test_all_ordered(self): + self.category = "All" + self.data.ta.strategy(ordered=True, verbose=verbose, timed=strategy_timed) + self.category = "All Ordered" # Rename for Speed Table + @skipUnless(verbose, "verbose mode only") def test_all_strategy(self): self.data.ta.strategy(pandas_ta.AllStrategy, verbose=verbose, timed=strategy_timed) @@ -76,6 +81,14 @@ class TestStrategyMethods(TestCase): self.category = "All" self.data.ta.strategy(self.category, verbose=verbose, timed=strategy_timed) + # @skipUnless(verbose, "verbose mode only") + def test_all_multiparams_strategy(self): + self.category = "All" + self.data.ta.strategy(self.category, length=10, verbose=verbose, timed=strategy_timed) + self.data.ta.strategy(self.category, length=50, verbose=verbose, timed=strategy_timed) + self.data.ta.strategy(self.category, fast=5, slow=10, verbose=verbose, timed=strategy_timed) + self.category = "All Multiruns with diff Args" # Rename for Speed Table + # @skip def test_candles_category(self): self.category = "Candles" @@ -86,6 +99,10 @@ class TestStrategyMethods(TestCase): self.category = "Common" self.data.ta.strategy(pandas_ta.CommonStrategy, verbose=verbose, timed=strategy_timed) + def test_cycles_category(self): + self.category = "Cycles" + self.data.ta.strategy(self.category, verbose=verbose, timed=strategy_timed) + # @skip def test_custom_a(self): self.category = "Custom A" @@ -148,6 +165,25 @@ class TestStrategyMethods(TestCase): ) self.data.ta.strategy(custom, verbose=verbose, timed=strategy_timed) + # @skip + def test_custom_a(self): + self.category = "Custom E" + + amat_logret_ta = [ + {"kind": "amat", "fast": 20, "slow": 50 }, # 2 + {"kind": "log_return", "cumulative": True}, # 1 + {"kind": "ema", "close": "CUMLOGRET_1", "length": 5} # 1 + ] + + custom = pandas_ta.Strategy( + "AMAT Log Returns", # name + amat_logret_ta, # ta + "AMAT Log Returns", # description + ) + self.data.ta.strategy(custom, verbose=verbose, timed=strategy_timed, ordered=True) + self.data.ta.trend_return(trend=self.data["AMATe_LR_2"], cumulative=True, append=True) + self.assertEqual(len(self.data.columns), 13) + # @skip def test_momentum_category(self): self.category = "Momentum" @@ -182,3 +218,37 @@ class TestStrategyMethods(TestCase): def test_volume_category(self): self.category = "Volume" self.data.ta.strategy(self.category, verbose=verbose, timed=strategy_timed) + + # @skipUnless(verbose, "verbose mode only") + def test_all_no_multiprocessing(self): + self.category = "All with No Multiprocessing" + + cores = self.data.ta.cores + self.data.ta.cores = 0 + self.data.ta.strategy(verbose=verbose, timed=strategy_timed) + self.data.ta.cores = cores + + # @skipUnless(verbose, "verbose mode only") + def test_custom_no_multiprocessing(self): + self.category = "Custom A with No Multiprocessing" + + cores = self.data.ta.cores + self.data.ta.cores = 0 + + momo_bands_sma_ta = [ + {"kind": "rsi"}, # 1 + {"kind": "macd"}, # 3 + {"kind": "sma", "length": 50}, # 1 + {"kind": "sma", "length": 200 }, # 1 + {"kind": "bbands", "length": 20}, # 3 + {"kind": "log_return", "cumulative": True}, # 1 + {"kind": "ema", "close": "CUMLOGRET_1", "length": 5, "suffix": "CLR"} + ] + + custom = pandas_ta.Strategy( + "Commons with Cumulative Log Return EMA Chain", # name + momo_bands_sma_ta, # ta + "Common indicators with specific lengths and a chained indicator", # description + ) + self.data.ta.strategy(custom, verbose=verbose, timed=strategy_timed) + self.data.ta.cores = cores diff --git a/tests/test_utils.py b/tests/test_utils.py index 850ec2d..06cc553 100644 --- a/tests/test_utils.py +++ b/tests/test_utils.py @@ -303,7 +303,7 @@ class TestUtilities(TestCase): def test_to_utc(self): result = self.utils.to_utc(self.data.copy()) self.assertTrue(is_datetime64_ns_dtype(result.index)) - self.assertTrue(is_datetime64tz_dtype(result.index)) + self.assertTrue(is_datetime64tz_dtype(result.index)) def test_total_time(self): result = self.utils.total_time(self.data) @@ -326,3 +326,8 @@ class TestUtilities(TestCase): result = self.utils.total_time(self.data, "seconds") self.assertEqual(657158400.0, result) + + def test_version(self): + result = pandas_ta.version + self.assertIsInstance(result, str) + print(f"\nPandas TA v{result}") \ No newline at end of file