mirror of
https://github.com/OpenBB-finance/OpenBB.git
synced 2026-10-27 04:31:13 +00:00
1501 lines
50 KiB
Python
1501 lines
50 KiB
Python
### THIS FILE IS AUTO-GENERATED. DO NOT EDIT. ###
|
|
|
|
from openbb_core.app.static.container import Container
|
|
from openbb_core.app.model.obbject import OBBject
|
|
from openbb_core.app.model.custom_parameter import OpenBBCustomParameter
|
|
import openbb_provider
|
|
import pandas
|
|
import datetime
|
|
import pydantic
|
|
from pydantic import BaseModel
|
|
from inspect import Parameter
|
|
import typing
|
|
from typing import List, Dict, Union, Optional, Literal
|
|
from annotated_types import Ge, Le, Gt, Lt
|
|
<<<<<<< Updated upstream
|
|
from typing_extensions import Annotated
|
|
=======
|
|
import typing_extensions
|
|
>>>>>>> Stashed changes
|
|
from openbb_core.app.utils import df_to_basemodel
|
|
from openbb_core.app.static.decorators import validate
|
|
|
|
from openbb_core.app.static.filters import filter_inputs
|
|
|
|
from openbb_provider.abstract.data import Data
|
|
import openbb_core.app.model.obbject
|
|
import typing
|
|
|
|
|
|
class ROUTER_ta(Container):
|
|
"""/ta
|
|
ad
|
|
adosc
|
|
adx
|
|
aroon
|
|
atr
|
|
bbands
|
|
cci
|
|
cg
|
|
clenow
|
|
cones
|
|
demark
|
|
donchian
|
|
ema
|
|
fib
|
|
fisher
|
|
hma
|
|
ichimoku
|
|
kc
|
|
macd
|
|
obv
|
|
rsi
|
|
sma
|
|
stoch
|
|
vwap
|
|
wma
|
|
zlma
|
|
"""
|
|
|
|
def __repr__(self) -> str:
|
|
return self.__doc__ or ""
|
|
|
|
@validate(config=dict(arbitrary_types_allowed=True))
|
|
def ad(
|
|
self,
|
|
data: Union[List[Data], pandas.DataFrame],
|
|
index: str = "date",
|
|
offset: int = 0,
|
|
) -> OBBject[List[Data]]:
|
|
"""
|
|
The Accumulation/Distribution Line is similar to the On Balance
|
|
Volume (OBV), which sums the volume times +1/-1 based on whether the close is
|
|
higher than the previous close. The Accumulation/Distribution indicator, however
|
|
multiplies the volume by the close location value (CLV). The CLV is based on the
|
|
movement of the issue within a single bar and can be +1, -1 or zero.
|
|
|
|
|
|
The Accumulation/Distribution Line is interpreted by looking for a divergence in
|
|
the direction of the indicator relative to price. If the Accumulation/Distribution
|
|
Line is trending upward it indicates that the price may follow. Also, if the
|
|
Accumulation/Distribution Line becomes flat while the price is still rising (or falling)
|
|
then it signals an impending flattening of the price.
|
|
|
|
Parameters
|
|
----------
|
|
data : List[Data]
|
|
List of data to be used for the calculation.
|
|
index : str, optional
|
|
Index column name to use with `data`, by default "date".
|
|
offset : int, optional
|
|
Offset of the AD, by default 0.
|
|
|
|
Returns
|
|
-------
|
|
OBBject[List[Data]]
|
|
|
|
Examples
|
|
--------
|
|
>>> from openbb import obb
|
|
>>> stock_data = obb.stocks.load(symbol="TSLA", start_date="2023-01-01", provider="fmp")
|
|
>>> ad_data = obb.ta.ad(data=stock_data.results,offset=0)
|
|
""" # noqa: E501
|
|
|
|
inputs = filter_inputs(
|
|
data=data,
|
|
index=index,
|
|
offset=offset,
|
|
)
|
|
|
|
return self._run(
|
|
"/ta/ad",
|
|
**inputs,
|
|
)
|
|
|
|
@validate(config=dict(arbitrary_types_allowed=True))
|
|
def adosc(
|
|
self,
|
|
data: Union[List[Data], pandas.DataFrame],
|
|
index: str = "date",
|
|
fast: typing_extensions.Annotated[int, Gt(gt=0)] = 3,
|
|
slow: typing_extensions.Annotated[int, Gt(gt=0)] = 10,
|
|
offset: int = 0,
|
|
) -> OBBject[List[Data]]:
|
|
"""
|
|
Accumulation/Distribution Oscillator, also known as the Chaikin Oscillator
|
|
is essentially a momentum indicator, but of the Accumulation-Distribution line
|
|
rather than merely price. It looks at both the strength of price moves and the
|
|
underlying buying and selling pressure during a given time period. The oscillator
|
|
reading above zero indicates net buying pressure, while one below zero registers
|
|
net selling pressure. Divergence between the indicator and pure price moves are
|
|
the most common signals from the indicator, and often flag market turning points.
|
|
|
|
Parameters
|
|
----------
|
|
data : List[Data]
|
|
List of data to be used for the calculation.
|
|
fast : PositiveInt, optional
|
|
Number of periods to be used for the fast calculation, by default 3.
|
|
slow : PositiveInt, optional
|
|
Number of periods to be used for the slow calculation, by default 10.
|
|
offset : int, optional
|
|
Offset to be used for the calculation, by default 0.
|
|
|
|
Returns
|
|
-------
|
|
OBBject[List[Data]]
|
|
|
|
Examples
|
|
--------
|
|
>>> from openbb import obb
|
|
>>> stock_data = obb.stocks.load(symbol="TSLA", start_date="2023-01-01", provider="fmp")
|
|
>>> adosc_data = obb.ta.adosc(data=stock_data.results, fast=3, slow=10, offset=0)
|
|
""" # noqa: E501
|
|
|
|
inputs = filter_inputs(
|
|
data=data,
|
|
index=index,
|
|
fast=fast,
|
|
slow=slow,
|
|
offset=offset,
|
|
)
|
|
|
|
return self._run(
|
|
"/ta/adosc",
|
|
**inputs,
|
|
)
|
|
|
|
@validate(config=dict(arbitrary_types_allowed=True))
|
|
def adx(
|
|
self,
|
|
data: Union[List[Data], pandas.DataFrame],
|
|
index: str = "date",
|
|
length: int = 50,
|
|
scalar: float = 100.0,
|
|
drift: int = 1,
|
|
chart: bool = False,
|
|
) -> OBBject[List[Data]]:
|
|
"""
|
|
The ADX is a Welles Wilder style moving average of the Directional Movement Index (DX).
|
|
The values range from 0 to 100, but rarely get above 60. To interpret the ADX, consider
|
|
a high number to be a strong trend, and a low number, a weak trend.
|
|
|
|
Parameters
|
|
----------
|
|
data : List[Data]
|
|
List of data to be used for the calculation.
|
|
index : str, optional
|
|
Index column name to use with `data`, by default "date".
|
|
length : int, optional
|
|
Number of periods for the ADX, by default 50.
|
|
scalar : float, optional
|
|
Scalar value for the ADX, by default 100.0.
|
|
drift : int, optional
|
|
Drift value for the ADX, by default 1.
|
|
|
|
Returns
|
|
-------
|
|
OBBject[List[Data]]
|
|
The calculated data.
|
|
|
|
Examples
|
|
--------
|
|
>>> from openbb import obb
|
|
>>> stock_data = obb.stocks.load(symbol="TSLA", start_date="2023-01-01", provider="fmp")
|
|
>>> adx_data = obb.ta.adx(data=stock_data.results,length=50,scalar=100.0,drift=1)
|
|
""" # noqa: E501
|
|
|
|
inputs = filter_inputs(
|
|
data=data,
|
|
index=index,
|
|
length=length,
|
|
scalar=scalar,
|
|
drift=drift,
|
|
chart=chart,
|
|
)
|
|
|
|
return self._run(
|
|
"/ta/adx",
|
|
**inputs,
|
|
)
|
|
|
|
@validate(config=dict(arbitrary_types_allowed=True))
|
|
def aroon(
|
|
self,
|
|
data: Union[List[Data], pandas.DataFrame],
|
|
index: str = "date",
|
|
length: int = 25,
|
|
scalar: int = 100,
|
|
chart: bool = False,
|
|
) -> OBBject[List[Data]]:
|
|
"""
|
|
The word aroon is Sanskrit for "dawn's early light." The Aroon
|
|
indicator attempts to show when a new trend is dawning. The indicator consists
|
|
of two lines (Up and Down) that measure how long it has been since the highest
|
|
high/lowest low has occurred within an n period range.
|
|
|
|
When the Aroon Up is staying between 70 and 100 then it indicates an upward trend.
|
|
When the Aroon Down is staying between 70 and 100 then it indicates an downward trend.
|
|
A strong upward trend is indicated when the Aroon Up is above 70 while the Aroon Down is below 30.
|
|
Likewise, a strong downward trend is indicated when the Aroon Down is above 70 while
|
|
the Aroon Up is below 30. Also look for crossovers. When the Aroon Down crosses above
|
|
the Aroon Up, it indicates a weakening of the upward trend (and vice versa).
|
|
|
|
Parameters
|
|
----------
|
|
data : List[Data]
|
|
List of data to be used for the calculation.
|
|
index: str, optional
|
|
Index column name to use with `data`, by default "date".
|
|
length : int, optional
|
|
Number of periods to be used for the calculation, by default 25.
|
|
scalar : int, optional
|
|
Scalar to be used for the calculation, by default 100.
|
|
|
|
Returns
|
|
-------
|
|
OBBject[List[Data]]
|
|
The calculated data.
|
|
|
|
Examples
|
|
--------
|
|
>>> from openbb import obb
|
|
>>> stock_data = obb.stocks.load(symbol="TSLA", start_date="2023-01-01", provider="fmp")
|
|
>>> aroon_data = obb.ta.aroon(data=stock_data.results, length=25, scalar=100)
|
|
""" # noqa: E501
|
|
|
|
inputs = filter_inputs(
|
|
data=data,
|
|
index=index,
|
|
length=length,
|
|
scalar=scalar,
|
|
chart=chart,
|
|
)
|
|
|
|
return self._run(
|
|
"/ta/aroon",
|
|
**inputs,
|
|
)
|
|
|
|
@validate(config=dict(arbitrary_types_allowed=True))
|
|
def atr(
|
|
self,
|
|
data: Union[List[Data], pandas.DataFrame],
|
|
index: str = "date",
|
|
length: typing_extensions.Annotated[int, Gt(gt=0)] = 14,
|
|
mamode: Literal["rma", "ema", "sma", "wma"] = "rma",
|
|
drift: typing_extensions.Annotated[int, Ge(ge=0)] = 1,
|
|
offset: int = 0,
|
|
) -> OBBject[List[Data]]:
|
|
"""
|
|
Average True Range is used to measure volatility, especially volatility caused by
|
|
gaps or limit moves.
|
|
|
|
Parameters
|
|
----------
|
|
data : List[Data]
|
|
List of data to apply the indicator to.
|
|
index : str, optional
|
|
Index column name, by default "date"
|
|
length : PositiveInt, optional
|
|
It's period, by default 14
|
|
mamode : Literal["rma", "ema", "sma", "wma"], optional
|
|
Moving average mode, by default "rma"
|
|
drift : NonNegativeInt, optional
|
|
The difference period, by default 1
|
|
offset : int, optional
|
|
How many periods to offset the result, by default 0
|
|
|
|
Returns
|
|
-------
|
|
OBBject[List[Data]]
|
|
List of data with the indicator applied.
|
|
|
|
Examples
|
|
--------
|
|
>>> from openbb import obb
|
|
>>> stock_data = obb.stocks.load(symbol="TSLA", start_date="2023-01-01", provider="fmp")
|
|
>>> atr_data = obb.ta.atr(data=stock_data.results)
|
|
""" # noqa: E501
|
|
|
|
inputs = filter_inputs(
|
|
data=data,
|
|
index=index,
|
|
length=length,
|
|
mamode=mamode,
|
|
drift=drift,
|
|
offset=offset,
|
|
)
|
|
|
|
return self._run(
|
|
"/ta/atr",
|
|
**inputs,
|
|
)
|
|
|
|
@validate(config=dict(arbitrary_types_allowed=True))
|
|
def bbands(
|
|
self,
|
|
data: Union[List[Data], pandas.DataFrame],
|
|
target: str = "close",
|
|
index: str = "date",
|
|
length: int = 50,
|
|
std: typing_extensions.Annotated[float, Ge(ge=0)] = 2,
|
|
mamode: Literal["sma", "ema", "wma", "rma"] = "sma",
|
|
offset: int = 0,
|
|
) -> OBBject[List[Data]]:
|
|
"""
|
|
Bollinger Bands consist of three lines. The middle band is a simple
|
|
moving average (generally 20 periods) of the typical price (TP). The upper and lower
|
|
bands are F standard deviations (generally 2) above and below the middle band.
|
|
The bands widen and narrow when the volatility of the price is higher or lower,
|
|
respectively.
|
|
|
|
Bollinger Bands do not, in themselves, generate buy or sell signals;
|
|
they are an indicator of overbought or oversold conditions. When the price is near the
|
|
upper or lower band it indicates that a reversal may be imminent. The middle band
|
|
becomes a support or resistance level. The upper and lower bands can also be
|
|
interpreted as price targets. When the price bounces off of the lower band and crosses
|
|
the middle band, then the upper band becomes the price target.
|
|
|
|
Parameters
|
|
----------
|
|
data : List[Data]
|
|
List of data to be used for the calculation.
|
|
target : str
|
|
Target column name.
|
|
index : str, optional
|
|
Index column name to use with `data`, by default "date".
|
|
length : int, optional
|
|
Number of periods to be used for the calculation, by default 50.
|
|
std : NonNegativeFloat, optional
|
|
Standard deviation to be used for the calculation, by default 2.
|
|
mamode : Literal["sma", "ema", "wma", "rma"], optional
|
|
Moving average mode to be used for the calculation, by default "sma".
|
|
offset : int, optional
|
|
Offset to be used for the calculation, by default 0.
|
|
|
|
Returns
|
|
-------
|
|
OBBject[List[Data]]
|
|
The calculated data.
|
|
|
|
Examples
|
|
--------
|
|
>>> from openbb import obb
|
|
>>> stock_data = obb.stocks.load(symbol="TSLA", start_date="2023-01-01", provider="fmp")
|
|
>>> bbands = obb.ta.bbands(
|
|
>>> data=stock_data.results, target="close", length=50, std=2, mamode="sma", offset=0
|
|
>>> )
|
|
""" # noqa: E501
|
|
|
|
inputs = filter_inputs(
|
|
data=data,
|
|
target=target,
|
|
index=index,
|
|
length=length,
|
|
std=std,
|
|
mamode=mamode,
|
|
offset=offset,
|
|
)
|
|
|
|
return self._run(
|
|
"/ta/bbands",
|
|
**inputs,
|
|
)
|
|
|
|
@validate(config=dict(arbitrary_types_allowed=True))
|
|
def cci(
|
|
self,
|
|
data: Union[List[Data], pandas.DataFrame],
|
|
index: str = "date",
|
|
length: typing_extensions.Annotated[int, Gt(gt=0)] = 14,
|
|
scalar: typing_extensions.Annotated[float, Gt(gt=0)] = 0.015,
|
|
) -> OBBject[List[Data]]:
|
|
"""
|
|
The CCI is designed to detect beginning and ending market trends.
|
|
The range of 100 to -100 is the normal trading range. CCI values outside of this
|
|
range indicate overbought or oversold conditions. You can also look for price
|
|
divergence in the CCI. If the price is making new highs, and the CCI is not,
|
|
then a price correction is likely.
|
|
|
|
Parameters
|
|
----------
|
|
data : List[Data]
|
|
The data to use for the CCI calculation.
|
|
index : str, optional
|
|
Index column name to use with `data`, by default "date".
|
|
length : PositiveInt, optional
|
|
The length of the CCI, by default 14.
|
|
scalar : PositiveFloat, optional
|
|
The scalar of the CCI, by default 0.015.
|
|
|
|
Returns
|
|
-------
|
|
OBBject[List[Data]]
|
|
The CCI data.
|
|
""" # noqa: E501
|
|
|
|
inputs = filter_inputs(
|
|
data=data,
|
|
index=index,
|
|
length=length,
|
|
scalar=scalar,
|
|
)
|
|
|
|
return self._run(
|
|
"/ta/cci",
|
|
**inputs,
|
|
)
|
|
|
|
@validate(config=dict(arbitrary_types_allowed=True))
|
|
def cg(
|
|
self,
|
|
data: Union[List[Data], pandas.DataFrame],
|
|
index: str = "date",
|
|
length: typing_extensions.Annotated[int, Gt(gt=0)] = 14,
|
|
) -> OBBject[List[Data]]:
|
|
"""
|
|
The Center of Gravity indicator, in short, is used to anticipate future price movements
|
|
and to trade on price reversals as soon as they happen. However, just like other oscillators,
|
|
the COG indicator returns the best results in range-bound markets and should be avoided when
|
|
the price is trending. Traders who use it will be able to closely speculate the upcoming
|
|
price change of the asset.
|
|
|
|
Parameters
|
|
----------
|
|
data : List[Data]
|
|
The data to use for the COG calculation.
|
|
index : str, optional
|
|
Index column name to use with `data`, by default "date"
|
|
length : PositiveInt, optional
|
|
The length of the COG, by default 14
|
|
|
|
Returns
|
|
-------
|
|
OBBject[List[Data]]
|
|
The COG data.
|
|
|
|
Examples
|
|
--------
|
|
>>> from openbb import obb
|
|
>>> stock_data = obb.stocks.load(symbol="TSLA", start_date="2023-01-01", provider="fmp")
|
|
>>> cg_data = obb.ta.cg(data=stock_data.results, length=14)
|
|
""" # noqa: E501
|
|
|
|
inputs = filter_inputs(
|
|
data=data,
|
|
index=index,
|
|
length=length,
|
|
)
|
|
|
|
return self._run(
|
|
"/ta/cg",
|
|
**inputs,
|
|
)
|
|
|
|
@validate(config=dict(arbitrary_types_allowed=True))
|
|
def clenow(
|
|
self,
|
|
data: Union[List[Data], pandas.DataFrame],
|
|
index: str = "date",
|
|
target: str = "close",
|
|
period: typing_extensions.Annotated[int, Gt(gt=0)] = 90,
|
|
) -> OBBject[List[Data]]:
|
|
"""
|
|
Clenow Volatility Adjusted Momentum.
|
|
|
|
Parameters
|
|
----------
|
|
data : List[Data]
|
|
List of data to be used for the calculation.
|
|
index : str, optional
|
|
Index column name to use with `data`, by default "date".
|
|
target : str, optional
|
|
Target column name, by default "close".
|
|
period : PositiveInt, optional
|
|
Number of periods for the momentum, by default 90.
|
|
|
|
Returns
|
|
-------
|
|
OBBject[List[Data]]
|
|
The calculated data.
|
|
|
|
Examples
|
|
--------
|
|
>>> from openbb import obb
|
|
>>> stock_data = obb.stocks.load(symbol="TSLA", start_date="2023-01-01", provider="fmp")
|
|
>>> clenow_data = obb.ta.clenow(data=stock_data.results,period=90)
|
|
""" # noqa: E501
|
|
|
|
inputs = filter_inputs(
|
|
data=data,
|
|
index=index,
|
|
target=target,
|
|
period=period,
|
|
)
|
|
|
|
return self._run(
|
|
"/ta/clenow",
|
|
**inputs,
|
|
)
|
|
|
|
@validate(config=dict(arbitrary_types_allowed=True))
|
|
def cones(
|
|
self,
|
|
data: Union[List[Data], pandas.DataFrame],
|
|
index: str = "date",
|
|
lower_q: float = 0.25,
|
|
upper_q: float = 0.75,
|
|
model: Literal[
|
|
"STD",
|
|
"Parkinson",
|
|
"Garman-Klass",
|
|
"Hodges-Tompkins",
|
|
"Rogers-Satchell",
|
|
"Yang-Zhang",
|
|
] = "STD",
|
|
is_crypto: bool = False,
|
|
) -> OBBject[List[Data]]:
|
|
"""Calculate the realized volatility quantiles over rolling windows of time.
|
|
|
|
The model for calculating volatility is selectable.
|
|
|
|
Parameters
|
|
----------
|
|
data : List[Data]
|
|
The data to use for the calculation.
|
|
index : str, optional
|
|
Index column name to use with `data`, by default "date"
|
|
lower_q : float, optional
|
|
The lower quantile value for calculations
|
|
upper_q : float, optional
|
|
The upper quantile value for calculations
|
|
model : Literal["STD", "Parkinson", "Garman-Klass", "Hodges-Tompkins", "Rogers-Satchell", "Yang-Zhang"], optional
|
|
The model used to calculate realized volatility
|
|
|
|
Standard deviation measures how widely returns are dispersed from the average return.
|
|
It is the most common (and biased) estimator of volatility.
|
|
|
|
Parkinson volatility uses the high and low price of the day rather than just close to close prices.
|
|
It is useful for capturing large price movements during the day.
|
|
|
|
Garman-Klass volatility extends Parkinson volatility by taking into account the opening and closing price.
|
|
As markets are most active during the opening and closing of a trading session;
|
|
it makes volatility estimation more accurate.
|
|
|
|
Hodges-Tompkins volatility is a bias correction for estimation using an overlapping data sample.
|
|
It produces unbiased estimates and a substantial gain in efficiency.
|
|
|
|
Rogers-Satchell is an estimator for measuring the volatility with an average return not equal to zero.
|
|
Unlike Parkinson and Garman-Klass estimators, Rogers-Satchell incorporates a drift term,
|
|
mean return not equal to zero.
|
|
|
|
Yang-Zhang volatility is the combination of the overnight (close-to-open volatility).
|
|
It is a weighted average of the Rogers-Satchell volatility and the open-to-close volatility.
|
|
is_crypto : bool, optional
|
|
Whether the data is crypto or not. If True, volatility is calculated for 365 days instead of 252
|
|
|
|
Returns
|
|
-------
|
|
OBBject[List[Data]]
|
|
The cones data.
|
|
|
|
Examples
|
|
--------
|
|
>>> from openbb import obb
|
|
>>> stock_data = obb.stocks.load(symbol="TSLA", start_date="2023-01-01", provider="fmp")
|
|
>>> cones_data = obb.ta.cones(data=stock_data.results, lower_q=0.25, upper_q=0.75, model="STD")
|
|
""" # noqa: E501
|
|
|
|
inputs = filter_inputs(
|
|
data=data,
|
|
index=index,
|
|
lower_q=lower_q,
|
|
upper_q=upper_q,
|
|
model=model,
|
|
is_crypto=is_crypto,
|
|
)
|
|
|
|
return self._run(
|
|
"/ta/cones",
|
|
**inputs,
|
|
)
|
|
|
|
@validate(config=dict(arbitrary_types_allowed=True))
|
|
def demark(
|
|
self,
|
|
data: Union[List[Data], pandas.DataFrame],
|
|
index: str = "date",
|
|
target: str = "close",
|
|
show_all: bool = True,
|
|
asint: bool = True,
|
|
offset: int = 0,
|
|
) -> OBBject[List[Data]]:
|
|
"""
|
|
Demark sequential indicator
|
|
|
|
Parameters
|
|
----------
|
|
data : List[Data]
|
|
List of data to be used for the calculation.
|
|
index : str, optional
|
|
Index column name to use with `data`, by default "date".
|
|
target : str, optional
|
|
Target column name, by default "close".
|
|
show_all : bool, optional
|
|
Show 1 - 13. If set to False, show 6 - 9
|
|
asint : bool, optional
|
|
If True, fill NAs with 0 and change type to int, by default True.
|
|
offset : int, optional
|
|
How many periods to offset the result
|
|
|
|
Returns
|
|
-------
|
|
OBBject[List[Data]]
|
|
The calculated data.
|
|
|
|
Examples
|
|
--------
|
|
>>> from openbb import obb
|
|
>>> stock_data = obb.stocks.load(symbol="TSLA", start_date="2023-01-01", provider="fmp")
|
|
>>> demark_data = obb.ta.demark(data=stock_data.results,offset=0)
|
|
""" # noqa: E501
|
|
|
|
inputs = filter_inputs(
|
|
data=data,
|
|
index=index,
|
|
target=target,
|
|
show_all=show_all,
|
|
asint=asint,
|
|
offset=offset,
|
|
)
|
|
|
|
return self._run(
|
|
"/ta/demark",
|
|
**inputs,
|
|
)
|
|
|
|
@validate(config=dict(arbitrary_types_allowed=True))
|
|
def donchian(
|
|
self,
|
|
data: Union[List[Data], pandas.DataFrame],
|
|
index: str = "date",
|
|
lower_length: typing_extensions.Annotated[int, Gt(gt=0)] = 20,
|
|
upper_length: typing_extensions.Annotated[int, Gt(gt=0)] = 20,
|
|
offset: int = 0,
|
|
) -> OBBject[List[Data]]:
|
|
"""
|
|
Donchian Channels are three lines generated by moving average
|
|
calculations that comprise an indicator formed by upper and lower
|
|
bands around a midrange or median band. The upper band marks the
|
|
highest price of a security over N periods while the lower band
|
|
marks the lowest price of a security over N periods. The area
|
|
between the upper and lower bands represents the Donchian Channel.
|
|
|
|
Parameters
|
|
----------
|
|
data : List[Data]
|
|
List of data to be used for the calculation.
|
|
index : str, optional
|
|
Index column name to use with `data`, by default "date".
|
|
lower_length : PositiveInt, optional
|
|
Number of periods for the lower band, by default 20.
|
|
upper_length : PositiveInt, optional
|
|
Number of periods for the upper band, by default 20.
|
|
offset : int, optional
|
|
Offset of the Donchian Channel, by default 0.
|
|
|
|
Returns
|
|
-------
|
|
OBBject[List[Data]]
|
|
The calculated data.
|
|
|
|
Examples
|
|
--------
|
|
>>> from openbb import obb
|
|
>>> stock_data = obb.stocks.load(symbol="TSLA", start_date="2023-01-01", provider="fmp")
|
|
>>> donchian_data = obb.ta.donchian(data=stock_data.results,lower_length=20,upper_length=20,offset=0)
|
|
""" # noqa: E501
|
|
|
|
inputs = filter_inputs(
|
|
data=data,
|
|
index=index,
|
|
lower_length=lower_length,
|
|
upper_length=upper_length,
|
|
offset=offset,
|
|
)
|
|
|
|
return self._run(
|
|
"/ta/donchian",
|
|
**inputs,
|
|
)
|
|
|
|
@validate(config=dict(arbitrary_types_allowed=True))
|
|
def ema(
|
|
self,
|
|
data: Union[List[Data], pandas.DataFrame],
|
|
target: str = "close",
|
|
index: str = "date",
|
|
length: int = 50,
|
|
offset: int = 0,
|
|
chart: bool = False,
|
|
) -> OBBject[List[Data]]:
|
|
"""
|
|
The Exponential Moving Average is a staple of technical
|
|
analysis and is used in countless technical indicators. In a Simple Moving
|
|
Average, each value in the time period carries equal weight, and values outside
|
|
of the time period are not included in the average. However, the Exponential
|
|
Moving Average is a cumulative calculation, including all data. Past values have
|
|
a diminishing contribution to the average, while more recent values have a greater
|
|
contribution. This method allows the moving average to be more responsive to changes
|
|
in the data.
|
|
|
|
Parameters
|
|
----------
|
|
data : List[Data]
|
|
The data to use for the calculation.
|
|
target : str
|
|
Target column name.
|
|
index : str, optional
|
|
Index column name to use with `data`, by default "date"
|
|
length : int, optional
|
|
The length of the calculation, by default 50.
|
|
offset : int, optional
|
|
The offset of the calculation, by default 0.
|
|
|
|
Returns
|
|
-------
|
|
OBBject[List[Data]]
|
|
The calculated data.
|
|
|
|
Examples
|
|
--------
|
|
>>> from openbb import obb
|
|
>>> stock_data = obb.stocks.load(symbol="TSLA", start_date="2023-01-01", provider="fmp")
|
|
>>> ema_data = obb.ta.ema(data=stock_data.results,target="close",length=50,offset=0)
|
|
|
|
""" # noqa: E501
|
|
|
|
inputs = filter_inputs(
|
|
data=data,
|
|
target=target,
|
|
index=index,
|
|
length=length,
|
|
offset=offset,
|
|
chart=chart,
|
|
)
|
|
|
|
return self._run(
|
|
"/ta/ema",
|
|
**inputs,
|
|
)
|
|
|
|
@validate(config=dict(arbitrary_types_allowed=True))
|
|
def fib(
|
|
self,
|
|
data: Union[List[Data], pandas.DataFrame],
|
|
index: str = "date",
|
|
close_column: Literal["close", "adj_close"] = "close",
|
|
period: typing_extensions.Annotated[int, Gt(gt=0)] = 120,
|
|
start_date: Union[str, None] = None,
|
|
end_date: Union[str, None] = None,
|
|
) -> OBBject[List[Data]]:
|
|
"""Create Fibonacci Retracement Levels.
|
|
|
|
Parameters
|
|
----------
|
|
data : List[Data]
|
|
List of data to apply the indicator to.
|
|
index : str, optional
|
|
Index column name, by default "date"
|
|
period : PositiveInt, optional
|
|
Period to calculate the indicator, by default 120
|
|
|
|
Returns
|
|
-------
|
|
OBBject[List[Data]]
|
|
List of data with the indicator applied.
|
|
|
|
Examples
|
|
--------
|
|
>>> from openbb import obb
|
|
>>> stock_data = obb.stocks.load(symbol="TSLA", start_date="2023-01-01", provider="fmp")
|
|
>>> fib_data = obb.ta.fib(data=stock_data.results, period=120)
|
|
""" # noqa: E501
|
|
|
|
inputs = filter_inputs(
|
|
data=data,
|
|
index=index,
|
|
close_column=close_column,
|
|
period=period,
|
|
start_date=start_date,
|
|
end_date=end_date,
|
|
)
|
|
|
|
return self._run(
|
|
"/ta/fib",
|
|
**inputs,
|
|
)
|
|
|
|
@validate(config=dict(arbitrary_types_allowed=True))
|
|
def fisher(
|
|
self,
|
|
data: Union[List[Data], pandas.DataFrame],
|
|
index: str = "date",
|
|
length: typing_extensions.Annotated[int, Gt(gt=0)] = 14,
|
|
signal: typing_extensions.Annotated[int, Gt(gt=0)] = 1,
|
|
) -> OBBject[List[Data]]:
|
|
"""
|
|
The Fisher Transform is a technical indicator created by John F. Ehlers
|
|
that converts prices into a Gaussian normal distribution.1 The indicator
|
|
highlights when prices have moved to an extreme, based on recent prices.
|
|
This may help in spotting turning points in the price of an asset. It also
|
|
helps show the trend and isolate the price waves within a trend.
|
|
|
|
Parameters
|
|
----------
|
|
data : List[Data]
|
|
List of data to apply the indicator to.
|
|
index : str, optional
|
|
Index column name, by default "date"
|
|
length : PositiveInt, optional
|
|
Fisher period, by default 14
|
|
signal : PositiveInt, optional
|
|
Fisher Signal period, by default 1
|
|
|
|
Returns
|
|
-------
|
|
OBBject[List[Data]]
|
|
List of data with the indicator applied.
|
|
|
|
Examples
|
|
--------
|
|
>>> from openbb import obb
|
|
>>> stock_data = obb.stocks.load(symbol="TSLA", start_date="2023-01-01", provider="fmp")
|
|
>>> fisher_data = obb.ta.fisher(data=stock_data.results, length=14, signal=1)
|
|
""" # noqa: E501
|
|
|
|
inputs = filter_inputs(
|
|
data=data,
|
|
index=index,
|
|
length=length,
|
|
signal=signal,
|
|
)
|
|
|
|
return self._run(
|
|
"/ta/fisher",
|
|
**inputs,
|
|
)
|
|
|
|
@validate(config=dict(arbitrary_types_allowed=True))
|
|
def hma(
|
|
self,
|
|
data: Union[List[Data], pandas.DataFrame],
|
|
target: str = "close",
|
|
index: str = "date",
|
|
length: int = 50,
|
|
offset: int = 0,
|
|
chart: bool = False,
|
|
) -> OBBject[List[Data]]:
|
|
"""
|
|
The Hull Moving Average solves the age old dilemma of making a moving average
|
|
more responsive to current price activity whilst maintaining curve smoothness.
|
|
In fact the HMA almost eliminates lag altogether and manages to improve smoothing
|
|
at the same time.
|
|
|
|
Parameters
|
|
----------
|
|
data : List[Data]
|
|
List of data to be used for the calculation.
|
|
target : str
|
|
Target column name.
|
|
index : str, optional
|
|
Index column name to use with `data`, by default "date".
|
|
length : int, optional
|
|
Number of periods for the HMA, by default 50.
|
|
offset : int, optional
|
|
Offset of the HMA, by default 0.
|
|
|
|
Returns
|
|
-------
|
|
OBBject[List[Data]]
|
|
The calculated data.
|
|
|
|
Examples
|
|
--------
|
|
>>> from openbb import obb
|
|
>>> stock_data = obb.stocks.load(symbol="TSLA", start_date="2023-01-01", provider="fmp")
|
|
>>> hma_data = obb.ta.hma(data=stock_data.results,target="close",length=50,offset=0)
|
|
""" # noqa: E501
|
|
|
|
inputs = filter_inputs(
|
|
data=data,
|
|
target=target,
|
|
index=index,
|
|
length=length,
|
|
offset=offset,
|
|
chart=chart,
|
|
)
|
|
|
|
return self._run(
|
|
"/ta/hma",
|
|
**inputs,
|
|
)
|
|
|
|
@validate(config=dict(arbitrary_types_allowed=True))
|
|
def ichimoku(
|
|
self,
|
|
data: Union[List[Data], pandas.DataFrame],
|
|
index: str = "date",
|
|
conversion: typing_extensions.Annotated[int, Gt(gt=0)] = 9,
|
|
base: typing_extensions.Annotated[int, Gt(gt=0)] = 26,
|
|
lagging: typing_extensions.Annotated[int, Gt(gt=0)] = 52,
|
|
offset: typing_extensions.Annotated[int, Gt(gt=0)] = 26,
|
|
lookahead: bool = False,
|
|
) -> OBBject[List[Data]]:
|
|
"""
|
|
The Ichimoku Cloud, also known as Ichimoku Kinko Hyo, is a versatile indicator that
|
|
defines support and resistance, identifies trend direction, gauges momentum and provides
|
|
trading signals. Ichimoku Kinko Hyo translates into "one look equilibrium chart". With
|
|
one look, chartists can identify the trend and look for potential signals within that trend.
|
|
|
|
Parameters
|
|
----------
|
|
data : List[Data]
|
|
List of data to be used for the calculation.
|
|
index : str, optional
|
|
Index column name to use with `data`, by default "date".
|
|
conversion : PositiveInt, optional
|
|
Number of periods for the conversion line, by default 9.
|
|
base : PositiveInt, optional
|
|
Number of periods for the base line, by default 26.
|
|
lagging : PositiveInt, optional
|
|
Number of periods for the lagging span, by default 52.
|
|
offset : PositiveInt, optional
|
|
Number of periods for the offset, by default 26.
|
|
lookahead : bool, optional
|
|
drops the Chikou Span Column to prevent potential data leak
|
|
""" # noqa: E501
|
|
|
|
inputs = filter_inputs(
|
|
data=data,
|
|
index=index,
|
|
conversion=conversion,
|
|
base=base,
|
|
lagging=lagging,
|
|
offset=offset,
|
|
lookahead=lookahead,
|
|
)
|
|
|
|
return self._run(
|
|
"/ta/ichimoku",
|
|
**inputs,
|
|
)
|
|
|
|
@validate(config=dict(arbitrary_types_allowed=True))
|
|
def kc(
|
|
self,
|
|
data: Union[List[Data], pandas.DataFrame],
|
|
index: str = "date",
|
|
length: typing_extensions.Annotated[int, Gt(gt=0)] = 20,
|
|
scalar: typing_extensions.Annotated[float, Gt(gt=0)] = 20,
|
|
mamode: Literal["ema", "sma", "wma", "hma", "zlma"] = "ema",
|
|
offset: typing_extensions.Annotated[int, Ge(ge=0)] = 0,
|
|
) -> OBBject[List[Data]]:
|
|
"""
|
|
Keltner Channels are volatility-based bands that are placed
|
|
on either side of an asset's price and can aid in determining
|
|
the direction of a trend.The Keltner channel uses the average
|
|
true range (ATR) or volatility, with breaks above or below the top
|
|
and bottom barriers signaling a continuation.
|
|
|
|
Parameters
|
|
----------
|
|
data : List[Data]
|
|
The data to use for the Keltner Channels calculation.
|
|
index : str, optional
|
|
Index column name to use with `data`, by default "date"
|
|
length : PositiveInt, optional
|
|
The length of the Keltner Channels, by default 20
|
|
scalar : PositiveFloat, optional
|
|
The scalar to use for the Keltner Channels, by default 20
|
|
mamode : Literal["ema", "sma", "wma", "hma", "zlma"], optional
|
|
The moving average mode to use for the Keltner Channels, by default "ema"
|
|
offset : NonNegativeInt, optional
|
|
The offset to use for the Keltner Channels, by default 0
|
|
|
|
Returns
|
|
-------
|
|
OBBject[List[Data]]
|
|
The Keltner Channels data.
|
|
|
|
Examples
|
|
--------
|
|
>>> from openbb import obb
|
|
>>> stock_data = obb.stocks.load(symbol="TSLA", start_date="2023-01-01", provider="fmp")
|
|
>>> kc_data = obb.ta.kc(data=stock_data.results, length=20, scalar=20, ma_mode="ema", offset=0)
|
|
""" # noqa: E501
|
|
|
|
inputs = filter_inputs(
|
|
data=data,
|
|
index=index,
|
|
length=length,
|
|
scalar=scalar,
|
|
mamode=mamode,
|
|
offset=offset,
|
|
)
|
|
|
|
return self._run(
|
|
"/ta/kc",
|
|
**inputs,
|
|
)
|
|
|
|
@validate(config=dict(arbitrary_types_allowed=True))
|
|
def macd(
|
|
self,
|
|
data: Union[List[Data], pandas.DataFrame],
|
|
target: str = "close",
|
|
index: str = "date",
|
|
fast: int = 12,
|
|
slow: int = 26,
|
|
signal: int = 9,
|
|
chart: bool = False,
|
|
) -> OBBject[List[Data]]:
|
|
"""
|
|
The Moving Average Convergence Divergence (MACD) is the difference
|
|
between two Exponential Moving Averages. The Signal line is an Exponential Moving
|
|
Average of the MACD.
|
|
|
|
The MACD signals trend changes and indicates the start of new trend direction.
|
|
High values indicate overbought conditions, low values indicate oversold conditions.
|
|
Divergence with the price indicates an end to the current trend, especially if the
|
|
MACD is at extreme high or low values. When the MACD line crosses above the
|
|
signal line a buy signal is generated. When the MACD crosses below the signal line a
|
|
sell signal is generated. To confirm the signal, the MACD should be above zero for a buy,
|
|
and below zero for a sell.
|
|
|
|
Parameters
|
|
----------
|
|
data : List[Data]
|
|
List of data to be used for the calculation.
|
|
target : str
|
|
Target column name.
|
|
fast : int, optional
|
|
Number of periods for the fast EMA, by default 12.
|
|
slow : int, optional
|
|
Number of periods for the slow EMA, by default 26.
|
|
signal : int, optional
|
|
Number of periods for the signal EMA, by default 9.
|
|
|
|
Returns
|
|
-------
|
|
OBBject[List[Data]]
|
|
The calculated data.
|
|
|
|
Examples
|
|
--------
|
|
>>> from openbb import obb
|
|
>>> stock_data = obb.stocks.load(symbol="TSLA", start_date="2023-01-01", provider="fmp")
|
|
>>> macd_data = obb.ta.macd(data=stock_data.results,target="close",fast=12,slow=26,signal=9)
|
|
""" # noqa: E501
|
|
|
|
inputs = filter_inputs(
|
|
data=data,
|
|
target=target,
|
|
index=index,
|
|
fast=fast,
|
|
slow=slow,
|
|
signal=signal,
|
|
chart=chart,
|
|
)
|
|
|
|
return self._run(
|
|
"/ta/macd",
|
|
**inputs,
|
|
)
|
|
|
|
@validate(config=dict(arbitrary_types_allowed=True))
|
|
def obv(
|
|
self,
|
|
data: Union[List[Data], pandas.DataFrame],
|
|
index: str = "date",
|
|
offset: int = 0,
|
|
) -> OBBject[List[Data]]:
|
|
"""
|
|
The On Balance Volume (OBV) is a cumulative total of the up and
|
|
down volume. When the close is higher than the previous close, the volume is added
|
|
to the running total, and when the close is lower than the previous close, the volume
|
|
is subtracted from the running total.
|
|
|
|
To interpret the OBV, look for the OBV to move with the price or precede price moves.
|
|
If the price moves before the OBV, then it is a non-confirmed move. A series of rising peaks,
|
|
or falling troughs, in the OBV indicates a strong trend. If the OBV is flat, then the market
|
|
is not trending.
|
|
|
|
Parameters
|
|
----------
|
|
data : List[Data]
|
|
List of data to apply the indicator to.
|
|
index : str, optional
|
|
Index column name, by default "date"
|
|
offset : int, optional
|
|
How many periods to offset the result, by default 0.
|
|
|
|
Returns
|
|
-------
|
|
OBBject[List[Data]]
|
|
List of data with the indicator applied.
|
|
|
|
Examples
|
|
--------
|
|
>>> from openbb import obb
|
|
>>> stock_data = obb.stocks.load(symbol="TSLA", start_date="2023-01-01", provider="fmp")
|
|
>>> obv_data = obb.ta.obv(data=stock_data.results, offset=0)
|
|
""" # noqa: E501
|
|
|
|
inputs = filter_inputs(
|
|
data=data,
|
|
index=index,
|
|
offset=offset,
|
|
)
|
|
|
|
return self._run(
|
|
"/ta/obv",
|
|
**inputs,
|
|
)
|
|
|
|
@validate(config=dict(arbitrary_types_allowed=True))
|
|
def rsi(
|
|
self,
|
|
data: Union[List[Data], pandas.DataFrame],
|
|
target: str = "close",
|
|
index: str = "date",
|
|
length: int = 14,
|
|
scalar: float = 100.0,
|
|
drift: int = 1,
|
|
chart: bool = False,
|
|
) -> OBBject[List[Data]]:
|
|
"""
|
|
The Relative Strength Index (RSI) calculates a ratio of the
|
|
recent upward price movements to the absolute price movement. The RSI ranges
|
|
from 0 to 100. The RSI is interpreted as an overbought/oversold indicator when
|
|
the value is over 70/below 30. You can also look for divergence with price. If
|
|
the price is making new highs/lows, and the RSI is not, it indicates a reversal.
|
|
|
|
Parameters
|
|
----------
|
|
data : List[Data]
|
|
The data to use for the RSI calculation.
|
|
target : str
|
|
Target column name.
|
|
index : str, optional
|
|
Index column name to use with `data`, by default "date"
|
|
length : int, optional
|
|
The length of the RSI, by default 14
|
|
scalar : float, optional
|
|
The scalar to use for the RSI, by default 100.0
|
|
drift : int, optional
|
|
The drift to use for the RSI, by default 1
|
|
|
|
Returns
|
|
-------
|
|
OBBject[List[Data]]
|
|
The RSI data.
|
|
|
|
Examples
|
|
--------
|
|
>>> from openbb import obb
|
|
>>> stock_data = obb.stocks.load(symbol="TSLA", start_date="2023-01-01", provider="fmp")
|
|
>>> rsi_data = obb.ta.rsi(data=stock_data.results, target="close", length=14, scalar=100.0, drift=1)
|
|
""" # noqa: E501
|
|
|
|
inputs = filter_inputs(
|
|
data=data,
|
|
target=target,
|
|
index=index,
|
|
length=length,
|
|
scalar=scalar,
|
|
drift=drift,
|
|
chart=chart,
|
|
)
|
|
|
|
return self._run(
|
|
"/ta/rsi",
|
|
**inputs,
|
|
)
|
|
|
|
@validate(config=dict(arbitrary_types_allowed=True))
|
|
def sma(
|
|
self,
|
|
data: Union[List[Data], pandas.DataFrame],
|
|
target: str = "close",
|
|
index: str = "date",
|
|
length: int = 50,
|
|
offset: int = 0,
|
|
chart: bool = False,
|
|
) -> OBBject[List[Data]]:
|
|
"""
|
|
Moving Averages are used to smooth the data in an array to
|
|
help eliminate noise and identify trends. The Simple Moving Average is literally
|
|
the simplest form of a moving average. Each output value is the average of the
|
|
previous n values. In a Simple Moving Average, each value in the time period carries
|
|
equal weight, and values outside of the time period are not included in the average.
|
|
This makes it less responsive to recent changes in the data, which can be useful for
|
|
filtering out those changes.
|
|
|
|
Parameters
|
|
----------
|
|
data : List[Data]
|
|
List of data to be used for the calculation.
|
|
target : str
|
|
Target column name.
|
|
index : str, optional
|
|
Index column name to use with `data`, by default "date".
|
|
length : int, optional
|
|
Number of periods to be used for the calculation, by default 50.
|
|
offset : int, optional
|
|
Offset from the current period, by default 0.
|
|
|
|
Returns
|
|
-------
|
|
OBBject[List[Data]]
|
|
The calculated data.
|
|
|
|
Examples
|
|
--------
|
|
>>> from openbb import obb
|
|
>>> stock_data = obb.stocks.load(symbol="TSLA", start_date="2023-01-01", provider="fmp")
|
|
>>> sma_data = obb.ta.sma(data=stock_data.results,target="close",length=50,offset=0)
|
|
""" # noqa: E501
|
|
|
|
inputs = filter_inputs(
|
|
data=data,
|
|
target=target,
|
|
index=index,
|
|
length=length,
|
|
offset=offset,
|
|
chart=chart,
|
|
)
|
|
|
|
return self._run(
|
|
"/ta/sma",
|
|
**inputs,
|
|
)
|
|
|
|
@validate(config=dict(arbitrary_types_allowed=True))
|
|
def stoch(
|
|
self,
|
|
data: Union[List[Data], pandas.DataFrame],
|
|
index: str = "date",
|
|
fast_k_period: typing_extensions.Annotated[int, Ge(ge=0)] = 14,
|
|
slow_d_period: typing_extensions.Annotated[int, Ge(ge=0)] = 3,
|
|
slow_k_period: typing_extensions.Annotated[int, Ge(ge=0)] = 3,
|
|
) -> OBBject[List[Data]]:
|
|
"""
|
|
The Stochastic Oscillator measures where the close is in relation
|
|
to the recent trading range. The values range from zero to 100. %D values over 75
|
|
indicate an overbought condition; values under 25 indicate an oversold condition.
|
|
When the Fast %D crosses above the Slow %D, it is a buy signal; when it crosses
|
|
below, it is a sell signal. The Raw %K is generally considered too erratic to use
|
|
for crossover signals.
|
|
|
|
Parameters
|
|
----------
|
|
data : List[Data]
|
|
The data to use for the Stochastic Oscillator calculation.
|
|
index : str, optional
|
|
Index column name to use with `data`, by default "date".
|
|
fast_k_period : NonNegativeInt, optional
|
|
The fast %K period, by default 14.
|
|
slow_d_period : NonNegativeInt, optional
|
|
The slow %D period, by default 3.
|
|
slow_k_period : NonNegativeInt, optional
|
|
The slow %K period, by default 3.
|
|
|
|
Returns
|
|
-------
|
|
OBBject[List[Data]]
|
|
The Stochastic Oscillator data.
|
|
|
|
Examples
|
|
--------
|
|
>>> from openbb import obb
|
|
>>> stock_data = obb.stocks.load(symbol="TSLA", start_date="2023-01-01", provider="fmp")
|
|
>>> stoch_data = obb.ta.stoch(data=stock_data.results, fast_k_period=14, slow_d_period=3, slow_k_period=3)
|
|
""" # noqa: E501
|
|
|
|
inputs = filter_inputs(
|
|
data=data,
|
|
index=index,
|
|
fast_k_period=fast_k_period,
|
|
slow_d_period=slow_d_period,
|
|
slow_k_period=slow_k_period,
|
|
)
|
|
|
|
return self._run(
|
|
"/ta/stoch",
|
|
**inputs,
|
|
)
|
|
|
|
@validate(config=dict(arbitrary_types_allowed=True))
|
|
def vwap(
|
|
self,
|
|
data: Union[List[Data], pandas.DataFrame],
|
|
index: str = "date",
|
|
anchor: str = "D",
|
|
offset: int = 0,
|
|
) -> OBBject[List[Data]]:
|
|
"""
|
|
The Volume Weighted Average Price that measures the average typical price
|
|
by volume. It is typically used with intraday charts to identify general direction.
|
|
|
|
Parameters
|
|
----------
|
|
data : List[Data]
|
|
List of data to be used for the calculation.
|
|
index : str, optional
|
|
Index column name to use with `data`, by default "date".
|
|
anchor : str, optional
|
|
Anchor period to use for the calculation, by default "D".
|
|
See Timeseries Offset Aliases below for additional options:
|
|
https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#timeseries-offset-aliases
|
|
offset : int, optional
|
|
Offset from the current period, by default 0.
|
|
|
|
Returns
|
|
-------
|
|
OBBject[List[Data]]
|
|
The calculated data.
|
|
|
|
Examples
|
|
--------
|
|
>>> from openbb import obb
|
|
>>> stock_data = obb.stocks.load(symbol="TSLA", start_date="2023-01-01", provider="fmp")
|
|
>>> vwap_data = obb.ta.vwap(data=stock_data.results,anchor="D",offset=0)
|
|
""" # noqa: E501
|
|
|
|
inputs = filter_inputs(
|
|
data=data,
|
|
index=index,
|
|
anchor=anchor,
|
|
offset=offset,
|
|
)
|
|
|
|
return self._run(
|
|
"/ta/vwap",
|
|
**inputs,
|
|
)
|
|
|
|
@validate(config=dict(arbitrary_types_allowed=True))
|
|
def wma(
|
|
self,
|
|
data: Union[List[Data], pandas.DataFrame],
|
|
target: str = "close",
|
|
index: str = "date",
|
|
length: int = 50,
|
|
offset: int = 0,
|
|
chart: bool = False,
|
|
) -> OBBject[List[Data]]:
|
|
"""
|
|
A Weighted Moving Average puts more weight on recent data and less on past data.
|
|
This is done by multiplying each bar's price by a weighting factor. Because of its
|
|
unique calculation, WMA will follow prices more closely than a corresponding Simple
|
|
Moving Average.
|
|
|
|
Parameters
|
|
----------
|
|
data : List[Data]
|
|
The data to use for the calculation.
|
|
target : str
|
|
Target column name.
|
|
index : str, optional
|
|
Index column name to use with `data`, by default "date".
|
|
length : int, optional
|
|
The length of the WMA, by default 50.
|
|
offset : int, optional
|
|
The offset of the WMA, by default 0.
|
|
|
|
Returns
|
|
-------
|
|
OBBject[List[Data]]
|
|
The WMA data.
|
|
|
|
Examples
|
|
--------
|
|
>>> from openbb import obb
|
|
>>> stock_data = obb.stocks.load(symbol="TSLA", start_date="2023-01-01", provider="fmp")
|
|
>>> wma_data = obb.ta.wma(data=stock_data.results, target="close", length=50, offset=0)
|
|
""" # noqa: E501
|
|
|
|
inputs = filter_inputs(
|
|
data=data,
|
|
target=target,
|
|
index=index,
|
|
length=length,
|
|
offset=offset,
|
|
chart=chart,
|
|
)
|
|
|
|
return self._run(
|
|
"/ta/wma",
|
|
**inputs,
|
|
)
|
|
|
|
@validate(config=dict(arbitrary_types_allowed=True))
|
|
def zlma(
|
|
self,
|
|
data: Union[List[Data], pandas.DataFrame],
|
|
target: str = "close",
|
|
index: str = "date",
|
|
length: int = 50,
|
|
offset: int = 0,
|
|
chart: bool = False,
|
|
) -> OBBject[List[Data]]:
|
|
"""
|
|
The zero lag exponential moving average (ZLEMA) indicator
|
|
was created by John Ehlers and Ric Way. The idea is do a
|
|
regular exponential moving average (EMA) calculation but
|
|
on a de-lagged data instead of doing it on the regular data.
|
|
Data is de-lagged by removing the data from "lag" days ago
|
|
thus removing (or attempting to) the cumulative effect of
|
|
the moving average.
|
|
|
|
Parameters
|
|
----------
|
|
data : List[Data]
|
|
List of data to be used for the calculation.
|
|
target : str
|
|
Target column name.
|
|
index : str, optional
|
|
Index column name to use with `data`, by default "date".
|
|
length : int, optional
|
|
Number of periods to be used for the calculation, by default 50.
|
|
offset : int, optional
|
|
Offset to be used for the calculation, by default 0.
|
|
|
|
Returns
|
|
-------
|
|
OBBject[List[Data]]
|
|
The calculated data.
|
|
|
|
Examples
|
|
--------
|
|
>>> from openbb import obb
|
|
>>> stock_data = obb.stocks.load(symbol="TSLA", start_date="2023-01-01", provider="fmp")
|
|
>>> zlma_data = obb.ta.zlma(data=stock_data.results, target="close", length=50, offset=0)
|
|
""" # noqa: E501
|
|
|
|
inputs = filter_inputs(
|
|
data=data,
|
|
target=target,
|
|
index=index,
|
|
length=length,
|
|
offset=offset,
|
|
chart=chart,
|
|
)
|
|
|
|
return self._run(
|
|
"/ta/zlma",
|
|
**inputs,
|
|
)
|