diff --git a/openbb_platform/openbb/package/__extensions__.py b/openbb_platform/openbb/package/__extensions__.py index f55f965b650e..198cf9254983 100644 --- a/openbb_platform/openbb/package/__extensions__.py +++ b/openbb_platform/openbb/package/__extensions__.py @@ -9,25 +9,38 @@ class Extensions(Container): """ Routers: /crypto + /econometrics /economy /fixedincome /forex + /futures /news + /qa /stocks + /ta Extensions: - crypto@0.1.0a2 + - econometrics@0.1.0a2 - economy@0.1.0a2 - fixedincome@0.1.0a2 - forex@0.1.0a2 + - futures@0.1.0a2 - news@0.1.0a2 + - openbb_charting@0.1.0a2 + - qa@0.1.0a2 - stocks@0.1.0a2 + - ta@0.1.0a2 + - alpha_vantage@0.1.0a2 - benzinga@0.1.0a2 + - cboe@0.1.0a2 - fmp@0.1.0a2 - fred@0.1.0a2 - intrinio@0.1.0a2 - - polygon@0.1.0a2 """ + - polygon@0.1.0a2 + - quandl@0.1.0a2 + - yfinance@0.1.0a2 """ # fmt: on def __repr__(self) -> str: return self.__doc__ or "" @@ -38,6 +51,12 @@ def crypto(self): # route = "/crypto" return crypto.ROUTER_crypto(command_runner=self._command_runner) + @property + def econometrics(self): # route = "/econometrics" + from . import econometrics + + return econometrics.ROUTER_econometrics(command_runner=self._command_runner) + @property def economy(self): # route = "/economy" from . import economy @@ -56,14 +75,32 @@ def forex(self): # route = "/forex" return forex.ROUTER_forex(command_runner=self._command_runner) + @property + def futures(self): # route = "/futures" + from . import futures + + return futures.ROUTER_futures(command_runner=self._command_runner) + @property def news(self): # route = "/news" from . import news return news.ROUTER_news(command_runner=self._command_runner) + @property + def qa(self): # route = "/qa" + from . import qa + + return qa.ROUTER_qa(command_runner=self._command_runner) + @property def stocks(self): # route = "/stocks" from . import stocks return stocks.ROUTER_stocks(command_runner=self._command_runner) + + @property + def ta(self): # route = "/ta" + from . import ta + + return ta.ROUTER_ta(command_runner=self._command_runner) diff --git a/openbb_platform/openbb/package/crypto.py b/openbb_platform/openbb/package/crypto.py index 16e475865b44..756dd45975de 100644 --- a/openbb_platform/openbb/package/crypto.py +++ b/openbb_platform/openbb/package/crypto.py @@ -41,7 +41,7 @@ def load( description="End date of the data, in YYYY-MM-DD format." ), ] = None, - provider: Union[Literal["fmp", "polygon"], None] = None, + provider: Union[Literal["fmp", "polygon", "yfinance"], None] = None, **kwargs ) -> OBBject[List[Data]]: """Crypto Historical Price. @@ -54,14 +54,14 @@ def load( Start date of the data, in YYYY-MM-DD format. end_date : Union[datetime.date, None] End date of the data, in YYYY-MM-DD format. - provider : Union[Literal['fmp', 'polygon'], None] + provider : Union[Literal['fmp', 'polygon', 'yfinance'], None] The provider to use for the query, by default None. If None, the provider specified in defaults is selected or 'fmp' if there is no default. timeseries : Optional[Union[typing_extensions.Annotated[int, Ge(ge=0)]]] Number of days to look back. (provider: fmp) - interval : Literal['1min', '5min', '15min', '30min', '1hour', '4hour', '1day'] - Data granularity. (provider: fmp) + interval : Optional[Union[Literal['1min', '5min', '15min', '30min', '1hour', '4hour', '1day'], Literal['1m', '2m', '5m', '15m', '30m', '60m', '90m', '1h', '1d', '5d', '1wk', '1mo', '3mo']]] + Data granularity. (provider: fmp, yfinance) multiplier : int Multiplier of the timespan. (provider: polygon) timespan : Literal['minute', 'hour', 'day', 'week', 'month', 'quarter', 'year'] @@ -72,13 +72,15 @@ def load( The number of data entries to return. (provider: polygon) adjusted : bool Whether the data is adjusted. (provider: polygon) + period : Optional[Union[Literal['1d', '5d', '1mo', '3mo', '6mo', '1y', '2y', '5y', '10y', 'ytd', 'max']]] + Period of the data to return. (provider: yfinance) Returns ------- OBBject results : Union[List[CryptoHistorical]] Serializable results. - provider : Union[Literal['fmp', 'polygon'], None] + provider : Union[Literal['fmp', 'polygon', 'yfinance'], None] Provider name. warnings : Optional[List[Warning_]] List of warnings. diff --git a/openbb_platform/openbb/package/econometrics.py b/openbb_platform/openbb/package/econometrics.py new file mode 100644 index 000000000000..f4a1e9f34227 --- /dev/null +++ b/openbb_platform/openbb/package/econometrics.py @@ -0,0 +1,518 @@ +### THIS FILE IS AUTO-GENERATED. DO NOT EDIT. ### + +from typing import Dict, List, Literal, Union + +import pandas +import typing_extensions +from annotated_types import Gt +from openbb_core.app.model.obbject import OBBject +from openbb_core.app.static.container import Container +from openbb_core.app.static.decorators import validate +from openbb_core.app.static.filters import filter_inputs +from openbb_provider.abstract.data import Data + + +class ROUTER_econometrics(Container): + """/econometrics + bgot + coint + corr + dwat + granger + ols + ols_summary + panelbols + panelfd + panelfmac + panelols + panelpols + panelre + unitroot + """ + + def __repr__(self) -> str: + return self.__doc__ or "" + + @validate(config=dict(arbitrary_types_allowed=True)) + def bgot( + self, + data: Union[List[Data], pandas.DataFrame], + y_column: str, + x_columns: List[str], + lags: typing_extensions.Annotated[int, Gt(gt=0)] = 1, + ) -> OBBject[Data]: + """Perform Breusch-Godfrey Lagrange Multiplier tests for residual autocorrelation. + + Parameters + ---------- + data: List[Data] + Input dataset. + y_column: str + Target column. + x_columns: str + List of columns to use as exogenous variables. + lags: PositiveInt + Number of lags to use in the test. + + Returns + ------- + OBBject[Data] + OBBject with the results being the score from the test. + """ # noqa: E501 + + inputs = filter_inputs( + data=data, + y_column=y_column, + x_columns=x_columns, + lags=lags, + ) + + return self._run( + "/econometrics/bgot", + **inputs, + ) + + @validate(config=dict(arbitrary_types_allowed=True)) + def coint( + self, data: Union[List[Data], pandas.DataFrame], columns: List[str] + ) -> OBBject[Data]: + """Show co-integration between two timeseries using the two step Engle-Granger test. + + Parameters + ---------- + data: List[Data] + Input dataset. + columns: List[str] + Data columns to check cointegration + maxlag: PositiveInt + Number of lags to use in the test. + + Returns + ------- + OBBject[Data] + OBBject with the results being the score from the test. + """ # noqa: E501 + + inputs = filter_inputs( + data=data, + columns=columns, + ) + + return self._run( + "/econometrics/coint", + **inputs, + ) + + @validate(config=dict(arbitrary_types_allowed=True)) + def corr(self, data: Union[List[Data], pandas.DataFrame]) -> OBBject[List[Data]]: + """Get the corrlelation matrix of an input dataset. + + Parameters + ---------- + data : List[Data] + Input dataset. + + Returns + ------- + OBBject[List[Data]] + Correlation matrix. + """ # noqa: E501 + + inputs = filter_inputs( + data=data, + ) + + return self._run( + "/econometrics/corr", + **inputs, + ) + + @validate(config=dict(arbitrary_types_allowed=True)) + def dwat( + self, + data: Union[List[Data], pandas.DataFrame], + y_column: str, + x_columns: List[str], + ) -> OBBject[Dict]: + """Perform Durbin-Watson test for autocorrelation. + + Parameters + ---------- + data: List[Data] + Input dataset. + y_column: str + Target column. + x_columns: str + List of columns to use as exogenous variables. + + Returns + ------- + OBBject[Data] + OBBject with the results being the score from the test. + """ # noqa: E501 + + inputs = filter_inputs( + data=data, + y_column=y_column, + x_columns=x_columns, + ) + + return self._run( + "/econometrics/dwat", + **inputs, + ) + + @validate(config=dict(arbitrary_types_allowed=True)) + def granger( + self, + data: Union[List[Data], pandas.DataFrame], + y_column: str, + x_column: str, + lag: typing_extensions.Annotated[int, Gt(gt=0)] = 3, + ) -> OBBject[Data]: + """Perform Granger causality test to determine if X "causes" y. + + Parameters + ---------- + data: List[Data] + Input dataset. + y_column: str + Target column. + x_column: str + Columns to use as exogenous variables. + lag: PositiveInt + Number of lags to use in the test. + + Returns + ------- + OBBject[Data] + OBBject with the results being the score from the test. + """ # noqa: E501 + + inputs = filter_inputs( + data=data, + y_column=y_column, + x_column=x_column, + lag=lag, + ) + + return self._run( + "/econometrics/granger", + **inputs, + ) + + @validate(config=dict(arbitrary_types_allowed=True)) + def ols( + self, + data: Union[List[Data], pandas.DataFrame], + y_column: str, + x_columns: List[str], + ) -> OBBject[Dict]: + """Perform OLS regression. This returns the model and results objects from statsmodels. + + Parameters + ---------- + data: List[Data] + Input dataset. + y_column: str + Target column. + x_columns: str + List of columns to use as exogenous variables. + + Returns + ------- + OBBject[Dict] + OBBject with the results being model and results objects. + """ # noqa: E501 + + inputs = filter_inputs( + data=data, + y_column=y_column, + x_columns=x_columns, + ) + + return self._run( + "/econometrics/ols", + **inputs, + ) + + @validate(config=dict(arbitrary_types_allowed=True)) + def ols_summary( + self, + data: Union[List[Data], pandas.DataFrame], + y_column: str, + x_columns: List[str], + ) -> OBBject[Data]: + """Perform OLS regression. This returns the summary object from statsmodels. + + Parameters + ---------- + data: List[Data] + Input dataset. + y_column: str + Target column. + x_columns: str + List of columns to use as exogenous variables. + + Returns + ------- + OBBject[Dict] + OBBject with the results being summary object. + """ # noqa: E501 + + inputs = filter_inputs( + data=data, + y_column=y_column, + x_columns=x_columns, + ) + + return self._run( + "/econometrics/ols_summary", + **inputs, + ) + + @validate(config=dict(arbitrary_types_allowed=True)) + def panelbols( + self, + data: Union[List[Data], pandas.DataFrame], + y_column: str, + x_columns: List[str], + ) -> OBBject[Dict]: + """Perform a Between estimator regression on panel data. + + Parameters + ---------- + data: List[Data] + Input dataset. + y_column: str + Target column. + x_columns: str + List of columns to use as exogenous variables. + + Returns + ------- + OBBject[Dict] + OBBject with the fit model returned + """ # noqa: E501 + + inputs = filter_inputs( + data=data, + y_column=y_column, + x_columns=x_columns, + ) + + return self._run( + "/econometrics/panelbols", + **inputs, + ) + + @validate(config=dict(arbitrary_types_allowed=True)) + def panelfd( + self, + data: Union[List[Data], pandas.DataFrame], + y_column: str, + x_columns: List[str], + ) -> OBBject[Dict]: + """Perform a first-difference estimate for panel data. + + Parameters + ---------- + data: List[Data] + Input dataset. + y_column: str + Target column. + x_columns: str + List of columns to use as exogenous variables. + + Returns + ------- + OBBject[Dict] + OBBject with the fit model returned + """ # noqa: E501 + + inputs = filter_inputs( + data=data, + y_column=y_column, + x_columns=x_columns, + ) + + return self._run( + "/econometrics/panelfd", + **inputs, + ) + + @validate(config=dict(arbitrary_types_allowed=True)) + def panelfmac( + self, + data: Union[List[Data], pandas.DataFrame], + y_column: str, + x_columns: List[str], + ) -> OBBject[Dict]: + """Fama-MacBeth estimator for panel data. + + Parameters + ---------- + data: List[Data] + Input dataset. + y_column: str + Target column. + x_columns: str + List of columns to use as exogenous variables. + + Returns + ------- + OBBject[Dict] + OBBject with the fit model returned + """ # noqa: E501 + + inputs = filter_inputs( + data=data, + y_column=y_column, + x_columns=x_columns, + ) + + return self._run( + "/econometrics/panelfmac", + **inputs, + ) + + @validate(config=dict(arbitrary_types_allowed=True)) + def panelols( + self, + data: Union[List[Data], pandas.DataFrame], + y_column: str, + x_columns: List[str], + ) -> OBBject[Dict]: + """One- and two-way fixed effects estimator for panel data. + + Parameters + ---------- + data: List[Data] + Input dataset. + y_column: str + Target column. + x_columns: str + List of columns to use as exogenous variables. + + Returns + ------- + OBBject[Dict] + OBBject with the fit model returned + """ # noqa: E501 + + inputs = filter_inputs( + data=data, + y_column=y_column, + x_columns=x_columns, + ) + + return self._run( + "/econometrics/panelols", + **inputs, + ) + + @validate(config=dict(arbitrary_types_allowed=True)) + def panelpols( + self, + data: Union[List[Data], pandas.DataFrame], + y_column: str, + x_columns: List[str], + ) -> OBBject[Dict]: + """Perform a Pooled coefficvient estimator regression on panel data. + + Parameters + ---------- + data: List[Data] + Input dataset. + y_column: str + Target column. + x_columns: str + List of columns to use as exogenous variables. + + Returns + ------- + OBBject[Dict] + OBBject with the fit model returned + """ # noqa: E501 + + inputs = filter_inputs( + data=data, + y_column=y_column, + x_columns=x_columns, + ) + + return self._run( + "/econometrics/panelpols", + **inputs, + ) + + @validate(config=dict(arbitrary_types_allowed=True)) + def panelre( + self, + data: Union[List[Data], pandas.DataFrame], + y_column: str, + x_columns: List[str], + ) -> OBBject[Dict]: + """Perform One-way Random Effects model for panel data. + + Parameters + ---------- + data: List[Data] + Input dataset. + y_column: str + Target column. + x_columns: str + List of columns to use as exogenous variables. + + Returns + ------- + OBBject[Dict] + OBBject with the fit model returned + """ # noqa: E501 + + inputs = filter_inputs( + data=data, + y_column=y_column, + x_columns=x_columns, + ) + + return self._run( + "/econometrics/panelre", + **inputs, + ) + + @validate(config=dict(arbitrary_types_allowed=True)) + def unitroot( + self, + data: Union[List[Data], pandas.DataFrame], + column: str, + regression: Literal["c", "ct", "ctt"] = "c", + ) -> OBBject[Data]: + """Perform Augmented Dickey-Fuller unit root test. + + Parameters + ---------- + data: List[Data] + Input dataset. + column: str + Data columns to check unit root + regression: str + Regression type to use in the test. Either "c" for constant only, "ct" for constant and trend, or "ctt" for + constant, trend, and trend-squared. + + Returns + ------- + OBBject[Data] + OBBject with the results being the score from the test. + """ # noqa: E501 + + inputs = filter_inputs( + data=data, + column=column, + regression=regression, + ) + + return self._run( + "/econometrics/unitroot", + **inputs, + ) diff --git a/openbb_platform/openbb/package/economy.py b/openbb_platform/openbb/package/economy.py index c56825f0614d..cfb143ae063b 100644 --- a/openbb_platform/openbb/package/economy.py +++ b/openbb_platform/openbb/package/economy.py @@ -16,10 +16,17 @@ class ROUTER_economy(Container): """/economy available_indices const + cot + cot_search cpi + european_index + european_index_constituents fred_index index + index_search + index_snapshots risk + sp500_multiples """ def __repr__(self) -> str: @@ -27,23 +34,25 @@ def __repr__(self) -> str: @validate def available_indices( - self, provider: Union[Literal["fmp"], None] = None, **kwargs + self, provider: Union[Literal["cboe", "fmp", "yfinance"], None] = None, **kwargs ) -> OBBject[List[Data]]: """Lists of available indices from a provider. Parameters ---------- - provider : Union[Literal['fmp'], None] + provider : Union[Literal['cboe', 'fmp', 'yfinance'], None] The provider to use for the query, by default None. - If None, the provider specified in defaults is selected or 'fmp' if there is + If None, the provider specified in defaults is selected or 'cboe' if there is no default. + europe : bool + Filter for European indices. False for US indices. (provider: cboe) Returns ------- OBBject results : Union[List[AvailableIndices]] Serializable results. - provider : Union[Literal['fmp'], None] + provider : Union[Literal['cboe', 'fmp', 'yfinance'], None] Provider name. warnings : Optional[List[Warning_]] List of warnings. @@ -58,11 +67,34 @@ def available_indices( Name of the index. currency : Optional[Union[str]] Currency the index is traded in. + isin : Optional[Union[str]] + ISIN code for the index. Valid only for European indices. (provider: cboe) + region : Optional[Union[str]] + Region for the index. Valid only for European indices (provider: cboe) + symbol : Optional[Union[str]] + Symbol for the index. (provider: cboe, yfinance) + description : Optional[Union[str]] + Description for the index. Valid only for US indices. (provider: cboe) + data_delay : Optional[Union[int]] + Data delay for the index. Valid only for US indices. (provider: cboe) + open_time : Optional[Union[datetime.time]] + Opening time for the index. Valid only for US indices. (provider: cboe) + close_time : Optional[Union[datetime.time]] + Closing time for the index. Valid only for US indices. (provider: cboe) + time_zone : Optional[Union[str]] + Time zone for the index. Valid only for US indices. (provider: cboe) + tick_days : Optional[Union[str]] + The trading days for the index. Valid only for US indices. (provider: cboe) + tick_frequency : Optional[Union[str]] + The frequency of the index ticks. Valid only for US indices. (provider: cboe) + tick_period : Optional[Union[str]] + The period of the index ticks. Valid only for US indices. (provider: cboe) stock_exchange : Optional[Union[str]] Stock exchange where the index is listed. (provider: fmp) exchange_short_name : Optional[Union[str]] Short name of the stock exchange where the index is listed. (provider: fmp) - """ # noqa: E501 + code : Optional[Union[str]] + ID code for keying the index in the OpenBB Terminal. (provider: yfinance)""" # noqa: E501 inputs = filter_inputs( provider_choices={ @@ -148,6 +180,162 @@ def const( **inputs, ) + @validate + def cot( + self, provider: Union[Literal["quandl"], None] = None, **kwargs + ) -> OBBject[List[Data]]: + """Lookup Commitment of Traders Reports by series ID. + + Parameters + ---------- + provider : Union[Literal['quandl'], None] + The provider to use for the query, by default None. + If None, the provider specified in defaults is selected or 'quandl' if there is + no default. + code : str + + CFTC series code. Use search_cot() to find the code. + Codes not listed in the curated list, but are published by on the Nasdaq Data Link website, are valid. + Certain symbols, such as "ES=F", or exact names are also valid. + Default report is: S&P 500 Consolidated (CME)) + (provider: quandl) + data_type : Optional[Union[Literal['F', 'FO', 'CITS']]] + + The type of data to reuturn. Default is "FO". + + F = Futures only + + FO = Futures and Options + + CITS = Commodity Index Trader Supplemental. Only valid for commodities. + (provider: quandl) + legacy_format : Optional[Union[bool]] + Returns the legacy format of report. Default is False. (provider: quandl) + report_type : Optional[Union[Literal['ALL', 'CHG', 'OLD', 'OTR']]] + + The type of report to return. Default is "ALL". + + ALL = All + + CHG = Change in Positions + + OLD = Old Crop Years + + OTR = Other Crop Years + (provider: quandl) + measure : Optional[Union[Literal['CR', 'NT', 'OI', 'CHG']]] + + The measure to return. Default is None. + + CR = Concentration Ratios + + NT = Number of Traders + + OI = Percent of Open Interest + + CHG = Change in Positions. Only valid when data_type is "CITS". + (provider: quandl) + start_date : Optional[Union[datetime.date]] + The start date of the time series. Defaults to all. (provider: quandl) + end_date : Optional[Union[datetime.date]] + The end date of the time series. Defaults to the most recent data. (provider: quandl) + transform : Optional[Union[Literal['diff', 'rdiff', 'cumul', 'normalize']]] + Transform the data as w/w difference, percent change, cumulative, or normalize. (provider: quandl) + + Returns + ------- + OBBject + results : Union[List[COT]] + Serializable results. + provider : Union[Literal['quandl'], None] + Provider name. + warnings : Optional[List[Warning_]] + List of warnings. + chart : Optional[Chart] + Chart object. + extra: Dict[str, Any] + Extra info. + + COT + ---""" # noqa: E501 + + inputs = filter_inputs( + provider_choices={ + "provider": provider, + }, + standard_params={}, + extra_params=kwargs, + ) + + return self._run( + "/economy/cot", + **inputs, + ) + + @validate + def cot_search( + self, + query: typing_extensions.Annotated[ + str, OpenBBCustomParameter(description="Search query.") + ] = "", + provider: Union[Literal["quandl"], None] = None, + **kwargs + ) -> OBBject[List[Data]]: + """Fuzzy search and list of curated Commitment of Traders Reports series information. + + Parameters + ---------- + query : str + Search query. + provider : Union[Literal['quandl'], None] + The provider to use for the query, by default None. + If None, the provider specified in defaults is selected or 'quandl' if there is + no default. + + Returns + ------- + OBBject + results : Union[List[COTSearch]] + Serializable results. + provider : Union[Literal['quandl'], None] + Provider name. + warnings : Optional[List[Warning_]] + List of warnings. + chart : Optional[Chart] + Chart object. + extra: Dict[str, Any] + Extra info. + + COTSearch + --------- + code : str + CFTC Code of the report. + name : str + Name of the underlying asset. + category : Optional[Union[str]] + Category of the underlying asset. + subcategory : Optional[Union[str]] + Subcategory of the underlying asset. + units : Optional[Union[str]] + The units for one contract. + symbol : Optional[Union[str]] + Trading symbol representing the underlying asset.""" # noqa: E501 + + inputs = filter_inputs( + provider_choices={ + "provider": provider, + }, + standard_params={ + "query": query, + }, + extra_params=kwargs, + ) + + return self._run( + "/economy/cot_search", + **inputs, + ) + @validate def cpi( self, @@ -298,6 +486,174 @@ def cpi( **inputs, ) + @validate + def european_index( + self, + symbol: typing_extensions.Annotated[ + Union[str, List[str]], + OpenBBCustomParameter(description="Symbol to get data for."), + ], + start_date: typing_extensions.Annotated[ + Union[datetime.date, None, str], + OpenBBCustomParameter( + description="Start date of the data, in YYYY-MM-DD format." + ), + ] = None, + end_date: typing_extensions.Annotated[ + Union[datetime.date, None, str], + OpenBBCustomParameter( + description="End date of the data, in YYYY-MM-DD format." + ), + ] = None, + provider: Union[Literal["cboe"], None] = None, + **kwargs + ) -> OBBject[List[Data]]: + """Get historical close values for select European indices. + + Parameters + ---------- + symbol : str + Symbol to get data for. + start_date : Union[datetime.date, None] + Start date of the data, in YYYY-MM-DD format. + end_date : Union[datetime.date, None] + End date of the data, in YYYY-MM-DD format. + provider : Union[Literal['cboe'], None] + The provider to use for the query, by default None. + If None, the provider specified in defaults is selected or 'cboe' if there is + no default. + interval : Optional[Union[Literal['1d', '1m']]] + Data granularity. (provider: cboe) + + Returns + ------- + OBBject + results : Union[List[EuropeanIndexHistorical]] + Serializable results. + provider : Union[Literal['cboe'], None] + Provider name. + warnings : Optional[List[Warning_]] + List of warnings. + chart : Optional[Chart] + Chart object. + extra: Dict[str, Any] + Extra info. + + EuropeanIndexHistorical + ----------------------- + date : datetime + The date of the data. + close : float + The close price of the symbol. + open : Optional[Union[float]] + Opening price for the interval. Only valid when interval is 1m. (provider: cboe) + high : Optional[Union[float]] + High price for the interval. Only valid when interval is 1m. (provider: cboe) + low : Optional[Union[float]] + Low price for the interval. Only valid when interval is 1m. (provider: cboe) + utc_datetime : Optional[Union[datetime]] + UTC datetime. Only valid when interval is 1m. (provider: cboe)""" # noqa: E501 + + inputs = filter_inputs( + provider_choices={ + "provider": provider, + }, + standard_params={ + "symbol": ",".join(symbol) if isinstance(symbol, list) else symbol, + "start_date": start_date, + "end_date": end_date, + }, + extra_params=kwargs, + ) + + return self._run( + "/economy/european_index", + **inputs, + ) + + @validate + def european_index_constituents( + self, + symbol: typing_extensions.Annotated[ + Union[str, List[str]], + OpenBBCustomParameter(description="Symbol to get data for."), + ], + provider: Union[Literal["cboe"], None] = None, + **kwargs + ) -> OBBject[List[Data]]: + """Get current levels for constituents of select European indices. + + Parameters + ---------- + symbol : str + Symbol to get data for. + provider : Union[Literal['cboe'], None] + The provider to use for the query, by default None. + If None, the provider specified in defaults is selected or 'cboe' if there is + no default. + + Returns + ------- + OBBject + results : Union[List[EuropeanIndexConstituents]] + Serializable results. + provider : Union[Literal['cboe'], None] + Provider name. + warnings : Optional[List[Warning_]] + List of warnings. + chart : Optional[Chart] + Chart object. + extra: Dict[str, Any] + Extra info. + + EuropeanIndexConstituents + ------------------------- + symbol : str + Symbol of the constituent company in the index. + price : float + Current price of the constituent company in the index. + open : float + The open price of the symbol. + high : float + The high price of the symbol. + low : float + The low price of the symbol. + close : float + The close price of the symbol. + volume : float + The volume of the symbol. + prev_close : Optional[Union[float]] + Previous closing price. (provider: cboe) + change : Optional[Union[float]] + Change in price. (provider: cboe) + change_percent : Optional[Union[float]] + Change in price as a percentage. (provider: cboe) + tick : Optional[Union[str]] + Whether the last sale was an up or down tick. (provider: cboe) + last_trade_timestamp : Optional[Union[datetime]] + Last trade timestamp for the symbol. (provider: cboe) + exchange_id : Optional[Union[int]] + The Exchange ID number. (provider: cboe) + seqno : Optional[Union[int]] + Sequence number of the last trade on the tape. (provider: cboe) + asset_type : Optional[Union[str]] + Type of asset. (provider: cboe)""" # noqa: E501 + + inputs = filter_inputs( + provider_choices={ + "provider": provider, + }, + standard_params={ + "symbol": ",".join(symbol) if isinstance(symbol, list) else symbol, + }, + extra_params=kwargs, + ) + + return self._run( + "/economy/european_index_constituents", + **inputs, + ) + @validate def fred_index( self, @@ -403,7 +759,7 @@ def index( description="End date of the data, in YYYY-MM-DD format." ), ] = None, - provider: Union[Literal["fmp", "polygon"], None] = None, + provider: Union[Literal["cboe", "fmp", "polygon", "yfinance"], None] = None, **kwargs ) -> OBBject[List[Data]]: """Get historical levels for an index. @@ -416,14 +772,14 @@ def index( Start date of the data, in YYYY-MM-DD format. end_date : Union[datetime.date, None] End date of the data, in YYYY-MM-DD format. - provider : Union[Literal['fmp', 'polygon'], None] + provider : Union[Literal['cboe', 'fmp', 'polygon', 'yfinance'], None] The provider to use for the query, by default None. - If None, the provider specified in defaults is selected or 'fmp' if there is + If None, the provider specified in defaults is selected or 'cboe' if there is no default. + interval : Optional[Union[Literal['1d', '1m'], Literal['1min', '5min', '15min', '30min', '1hour', '4hour', '1day'], Literal['1m', '2m', '5m', '15m', '30m', '60m', '90m', '1h', '1d', '5d', '1wk', '1mo', '3mo']]] + Use interval, 1m, for intraday prices during the most recent trading period. (provider: cboe); Data granularity. (provider: fmp); Data granularity. (provider: yfinance) timeseries : Optional[Union[typing_extensions.Annotated[int, Ge(ge=0)]]] Number of days to look back. (provider: fmp) - interval : Literal['1min', '5min', '15min', '30min', '1hour', '4hour', '1day'] - Data granularity. (provider: fmp) timespan : Literal['minute', 'hour', 'day', 'week', 'month', 'quarter', 'year'] Timespan of the data. (provider: polygon) sort : Literal['asc', 'desc'] @@ -434,13 +790,19 @@ def index( Whether the data is adjusted. (provider: polygon) multiplier : int Multiplier of the timespan. (provider: polygon) + period : Optional[Union[Literal['1d', '5d', '1mo', '3mo', '6mo', '1y', '2y', '5y', '10y', 'ytd', 'max']]] + Period of the data to return. (provider: yfinance) + prepost : bool + Include Pre and Post market data. (provider: yfinance) + rounding : bool + Round prices to two decimals? (provider: yfinance) Returns ------- OBBject results : Union[List[MajorIndicesHistorical]] Serializable results. - provider : Union[Literal['fmp', 'polygon'], None] + provider : Union[Literal['cboe', 'fmp', 'polygon', 'yfinance'], None] Provider name. warnings : Optional[List[Warning_]] List of warnings. @@ -463,6 +825,12 @@ def index( The close price of the symbol. volume : Optional[int] The volume of the symbol. + calls_volume : Optional[Union[float]] + Number of calls traded during the most recent trading period. Only valid if interval is 1m. (provider: cboe) + puts_volume : Optional[Union[float]] + Number of puts traded during the most recent trading period. Only valid if interval is 1m. (provider: cboe) + total_options_volume : Optional[Union[float]] + Total number of options traded during the most recent trading period. Only valid if interval is 1m. (provider: cboe) adj_close : Optional[Union[float]] Adjusted Close Price of the symbol. (provider: fmp) unadjusted_volume : Optional[Union[float]] @@ -496,6 +864,174 @@ def index( **inputs, ) + @validate + def index_search( + self, + query: typing_extensions.Annotated[ + str, OpenBBCustomParameter(description="Search query.") + ] = "", + symbol: typing_extensions.Annotated[ + Union[bool, List[str]], + OpenBBCustomParameter(description="Whether to search by ticker symbol."), + ] = False, + provider: Union[Literal["cboe"], None] = None, + **kwargs + ) -> OBBject[List[Data]]: + """Search for indices. + + Parameters + ---------- + query : str + Search query. + symbol : bool + Whether to search by ticker symbol. + provider : Union[Literal['cboe'], None] + The provider to use for the query, by default None. + If None, the provider specified in defaults is selected or 'cboe' if there is + no default. + europe : bool + Filter for European indices. False for US indices. (provider: cboe) + + Returns + ------- + OBBject + results : Union[List[IndexSearch]] + Serializable results. + provider : Union[Literal['cboe'], None] + Provider name. + warnings : Optional[List[Warning_]] + List of warnings. + chart : Optional[Chart] + Chart object. + extra: Dict[str, Any] + Extra info. + + IndexSearch + ----------- + symbol : str + Symbol of the index. + name : str + Name of the index. + isin : Optional[Union[str]] + ISIN code for the index. Valid only for European indices. (provider: cboe) + region : Optional[Union[str]] + Region for the index. Valid only for European indices (provider: cboe) + description : Optional[Union[str]] + Description for the index. (provider: cboe) + data_delay : Optional[Union[int]] + Data delay for the index. Valid only for US indices. (provider: cboe) + currency : Optional[Union[str]] + Currency for the index. (provider: cboe) + time_zone : Optional[Union[str]] + Time zone for the index. Valid only for US indices. (provider: cboe) + open_time : Optional[Union[datetime.time]] + Opening time for the index. Valid only for US indices. (provider: cboe) + close_time : Optional[Union[datetime.time]] + Closing time for the index. Valid only for US indices. (provider: cboe) + tick_days : Optional[Union[str]] + The trading days for the index. Valid only for US indices. (provider: cboe) + tick_frequency : Optional[Union[str]] + Tick frequency for the index. Valid only for US indices. (provider: cboe) + tick_period : Optional[Union[str]] + Tick period for the index. Valid only for US indices. (provider: cboe)""" # noqa: E501 + + inputs = filter_inputs( + provider_choices={ + "provider": provider, + }, + standard_params={ + "query": query, + "symbol": ",".join(symbol) if isinstance(symbol, list) else symbol, + }, + extra_params=kwargs, + ) + + return self._run( + "/economy/index_search", + **inputs, + ) + + @validate + def index_snapshots( + self, + region: typing_extensions.Annotated[ + Union[Literal["US", "EU"], None], + OpenBBCustomParameter( + description="The region to return. Currently supports US and EU." + ), + ] = "US", + provider: Union[Literal["cboe"], None] = None, + **kwargs + ) -> OBBject[List[Data]]: + """Get current levels for all indices from a provider. + + Parameters + ---------- + region : Union[Literal['US', 'EU'], None] + The region to return. Currently supports US and EU. + provider : Union[Literal['cboe'], None] + The provider to use for the query, by default None. + If None, the provider specified in defaults is selected or 'cboe' if there is + no default. + + Returns + ------- + OBBject + results : Union[List[IndexSnapshots]] + Serializable results. + provider : Union[Literal['cboe'], None] + Provider name. + warnings : Optional[List[Warning_]] + List of warnings. + chart : Optional[Chart] + Chart object. + extra: Dict[str, Any] + Extra info. + + IndexSnapshots + -------------- + symbol : str + Symbol of the index. + name : Optional[Union[str]] + Name of the index. + currency : Optional[Union[str]] + Currency of the index. + price : Optional[Union[float]] + Current price of the index. + open : Optional[Union[float]] + Opening price of the index. + high : Optional[Union[float]] + Highest price of the index. + low : Optional[Union[float]] + Lowest price of the index. + close : Optional[Union[float]] + Closing price of the index. + prev_close : Optional[Union[float]] + Previous closing price of the index. + change : Optional[Union[float]] + Change of the index. + change_percent : Optional[Union[float]] + Change percent of the index. + isin : Optional[Union[str]] + ISIN code for the index. Valid only for European indices. (provider: cboe) + last_trade_timestamp : Optional[Union[datetime]] + Last trade timestamp for the index. (provider: cboe)""" # noqa: E501 + + inputs = filter_inputs( + provider_choices={ + "provider": provider, + }, + standard_params={ + "region": region, + }, + extra_params=kwargs, + ) + + return self._run( + "/economy/index_snapshots", + **inputs, + ) + @validate def risk( self, provider: Union[Literal["fmp"], None] = None, **kwargs @@ -546,3 +1082,133 @@ def risk( "/economy/risk", **inputs, ) + + @validate + def sp500_multiples( + self, + series_name: typing_extensions.Annotated[ + Literal[ + "Shiller PE Ratio by Month", + "Shiller PE Ratio by Year", + "PE Ratio by Year", + "PE Ratio by Month", + "Dividend by Year", + "Dividend by Month", + "Dividend Growth by Quarter", + "Dividend Growth by Year", + "Dividend Yield by Year", + "Dividend Yield by Month", + "Earnings by Year", + "Earnings by Month", + "Earnings Growth by Year", + "Earnings Growth by Quarter", + "Real Earnings Growth by Year", + "Real Earnings Growth by Quarter", + "Earnings Yield by Year", + "Earnings Yield by Month", + "Real Price by Year", + "Real Price by Month", + "Inflation Adjusted Price by Year", + "Inflation Adjusted Price by Month", + "Sales by Year", + "Sales by Quarter", + "Sales Growth by Year", + "Sales Growth by Quarter", + "Real Sales by Year", + "Real Sales by Quarter", + "Real Sales Growth by Year", + "Real Sales Growth by Quarter", + "Price to Sales Ratio by Year", + "Price to Sales Ratio by Quarter", + "Price to Book Value Ratio by Year", + "Price to Book Value Ratio by Quarter", + "Book Value per Share by Year", + "Book Value per Share by Quarter", + ], + OpenBBCustomParameter( + description="The name of the series. Defaults to 'PE Ratio by Month'." + ), + ] = "PE Ratio by Month", + start_date: typing_extensions.Annotated[ + Union[str, None], + OpenBBCustomParameter( + description="The start date of the time series. Format: YYYY-MM-DD" + ), + ] = "", + end_date: typing_extensions.Annotated[ + Union[str, None], + OpenBBCustomParameter( + description="The end date of the time series. Format: YYYY-MM-DD" + ), + ] = "", + collapse: typing_extensions.Annotated[ + Union[Literal["daily", "weekly", "monthly", "quarterly", "annual"], None], + OpenBBCustomParameter( + description="Collapse the frequency of the time series." + ), + ] = "monthly", + transform: typing_extensions.Annotated[ + Union[Literal["diff", "rdiff", "cumul", "normalize"], None], + OpenBBCustomParameter(description="The transformation of the time series."), + ] = None, + provider: Union[Literal["quandl"], None] = None, + **kwargs + ) -> OBBject[List[Data]]: + """Historical S&P 500 multiples and Shiller PE ratios. + + Parameters + ---------- + series_name : Literal['Shiller PE Ratio by Month', 'Shiller PE Ratio by Year', 'PE Rat... + The name of the series. Defaults to 'PE Ratio by Month'. + start_date : Union[str, None] + The start date of the time series. Format: YYYY-MM-DD + end_date : Union[str, None] + The end date of the time series. Format: YYYY-MM-DD + collapse : Union[Literal['daily', 'weekly', 'monthly', 'quarterly', 'annual'... + Collapse the frequency of the time series. + transform : Union[Literal['diff', 'rdiff', 'cumul', 'normalize'], None] + The transformation of the time series. + provider : Union[Literal['quandl'], None] + The provider to use for the query, by default None. + If None, the provider specified in defaults is selected or 'quandl' if there is + no default. + + Returns + ------- + OBBject + results : Union[List[SP500Multiples]] + Serializable results. + provider : Union[Literal['quandl'], None] + Provider name. + warnings : Optional[List[Warning_]] + List of warnings. + chart : Optional[Chart] + Chart object. + extra: Dict[str, Any] + Extra info. + + SP500Multiples + -------------- + date : str + The date data for the time series. + value : float + The data value for the time series.""" # noqa: E501 + + inputs = filter_inputs( + provider_choices={ + "provider": provider, + }, + standard_params={ + "series_name": series_name, + "start_date": start_date, + "end_date": end_date, + "collapse": collapse, + "transform": transform, + }, + extra_params=kwargs, + ) + + return self._run( + "/economy/sp500_multiples", + **inputs, + ) diff --git a/openbb_platform/openbb/package/extension_map.json b/openbb_platform/openbb/package/extension_map.json index bd468205a5d8..fd19f57c957d 100644 --- a/openbb_platform/openbb/package/extension_map.json +++ b/openbb_platform/openbb/package/extension_map.json @@ -1,17 +1,26 @@ { "openbb_core_extension": [ "crypto@0.1.0a2", + "econometrics@0.1.0a2", "economy@0.1.0a2", "fixedincome@0.1.0a2", "forex@0.1.0a2", + "futures@0.1.0a2", "news@0.1.0a2", - "stocks@0.1.0a2" + "openbb_charting@0.1.0a2", + "qa@0.1.0a2", + "stocks@0.1.0a2", + "ta@0.1.0a2" ], "openbb_provider_extension": [ + "alpha_vantage@0.1.0a2", "benzinga@0.1.0a2", + "cboe@0.1.0a2", "fmp@0.1.0a2", "fred@0.1.0a2", "intrinio@0.1.0a2", - "polygon@0.1.0a2" + "polygon@0.1.0a2", + "quandl@0.1.0a2", + "yfinance@0.1.0a2" ] } \ No newline at end of file diff --git a/openbb_platform/openbb/package/forex.py b/openbb_platform/openbb/package/forex.py index b1c496695403..4924e15f268f 100644 --- a/openbb_platform/openbb/package/forex.py +++ b/openbb_platform/openbb/package/forex.py @@ -42,7 +42,7 @@ def load( description="End date of the data, in YYYY-MM-DD format." ), ] = None, - provider: Union[Literal["fmp", "polygon"], None] = None, + provider: Union[Literal["fmp", "polygon", "yfinance"], None] = None, **kwargs ) -> OBBject[List[Data]]: """Forex Intraday Price. @@ -55,12 +55,12 @@ def load( Start date of the data, in YYYY-MM-DD format. end_date : Union[datetime.date, None] End date of the data, in YYYY-MM-DD format. - provider : Union[Literal['fmp', 'polygon'], None] + provider : Union[Literal['fmp', 'polygon', 'yfinance'], None] The provider to use for the query, by default None. If None, the provider specified in defaults is selected or 'fmp' if there is no default. - interval : Literal['1min', '5min', '15min', '30min', '1hour', '4hour', '1day'] - Data granularity. (provider: fmp) + interval : Optional[Union[Literal['1min', '5min', '15min', '30min', '1hour', '4hour', '1day'], Literal['1m', '2m', '5m', '15m', '30m', '60m', '90m', '1h', '1d', '5d', '1wk', '1mo', '3mo']]] + Data granularity. (provider: fmp, yfinance) multiplier : int Multiplier of the timespan. (provider: polygon) timespan : Literal['minute', 'hour', 'day', 'week', 'month', 'quarter', 'year'] @@ -71,13 +71,15 @@ def load( The number of data entries to return. (provider: polygon) adjusted : bool Whether the data is adjusted. (provider: polygon) + period : Optional[Union[Literal['1d', '5d', '1mo', '3mo', '6mo', '1y', '2y', '5y', '10y', 'ytd', 'max']]] + Period of the data to return. (provider: yfinance) Returns ------- OBBject results : Union[List[ForexHistorical]] Serializable results. - provider : Union[Literal['fmp', 'polygon'], None] + provider : Union[Literal['fmp', 'polygon', 'yfinance'], None] Provider name. warnings : Optional[List[Warning_]] List of warnings. diff --git a/openbb_platform/openbb/package/futures.py b/openbb_platform/openbb/package/futures.py new file mode 100644 index 000000000000..6a57a26710d8 --- /dev/null +++ b/openbb_platform/openbb/package/futures.py @@ -0,0 +1,188 @@ +### THIS FILE IS AUTO-GENERATED. DO NOT EDIT. ### + +import datetime +from typing import List, Literal, Union + +import typing_extensions +from openbb_core.app.model.custom_parameter import OpenBBCustomParameter +from openbb_core.app.model.obbject import OBBject +from openbb_core.app.static.container import Container +from openbb_core.app.static.decorators import validate +from openbb_core.app.static.filters import filter_inputs +from openbb_provider.abstract.data import Data + + +class ROUTER_futures(Container): + """/futures + curve + load + """ + + def __repr__(self) -> str: + return self.__doc__ or "" + + @validate + def curve( + self, + symbol: typing_extensions.Annotated[ + Union[str, List[str]], + OpenBBCustomParameter(description="Symbol to get data for."), + ], + date: typing_extensions.Annotated[ + Union[datetime.date, None], + OpenBBCustomParameter(description="Historical date to search curve for."), + ] = None, + provider: Union[Literal["cboe", "yfinance"], None] = None, + **kwargs + ) -> OBBject[List[Data]]: + """Futures Historical Price. + + Parameters + ---------- + symbol : str + Symbol to get data for. + date : Union[datetime.date, None] + Historical date to search curve for. + provider : Union[Literal['cboe', 'yfinance'], None] + The provider to use for the query, by default None. + If None, the provider specified in defaults is selected or 'cboe' if there is + no default. + + Returns + ------- + OBBject + results : Union[List[FuturesCurve]] + Serializable results. + provider : Union[Literal['cboe', 'yfinance'], None] + Provider name. + warnings : Optional[List[Warning_]] + List of warnings. + chart : Optional[Chart] + Chart object. + extra: Dict[str, Any] + Extra info. + + FuturesCurve + ------------ + expiration : str + Futures expiration month. + price : Optional[Union[float]] + The close price of the symbol. + symbol : Optional[Union[str]] + The trading symbol for the tenor of future. (provider: cboe)""" # noqa: E501 + + inputs = filter_inputs( + provider_choices={ + "provider": provider, + }, + standard_params={ + "symbol": ",".join(symbol) if isinstance(symbol, list) else symbol, + "date": date, + }, + extra_params=kwargs, + ) + + return self._run( + "/futures/curve", + **inputs, + ) + + @validate + def load( + self, + symbol: typing_extensions.Annotated[ + Union[str, List[str]], + OpenBBCustomParameter(description="Symbol to get data for."), + ], + start_date: typing_extensions.Annotated[ + Union[datetime.date, None, str], + OpenBBCustomParameter( + description="Start date of the data, in YYYY-MM-DD format." + ), + ] = None, + end_date: typing_extensions.Annotated[ + Union[datetime.date, None, str], + OpenBBCustomParameter( + description="End date of the data, in YYYY-MM-DD format." + ), + ] = None, + expiration: typing_extensions.Annotated[ + Union[str, None], + OpenBBCustomParameter(description="Future expiry date with format YYYY-MM"), + ] = None, + provider: Union[Literal["yfinance"], None] = None, + **kwargs + ) -> OBBject[List[Data]]: + """Futures Historical Price. + + Parameters + ---------- + symbol : str + Symbol to get data for. + start_date : Union[datetime.date, None] + Start date of the data, in YYYY-MM-DD format. + end_date : Union[datetime.date, None] + End date of the data, in YYYY-MM-DD format. + expiration : Union[str, None] + Future expiry date with format YYYY-MM + provider : Union[Literal['yfinance'], None] + The provider to use for the query, by default None. + If None, the provider specified in defaults is selected or 'yfinance' if there is + no default. + interval : Optional[Union[Literal['1m', '2m', '5m', '15m', '30m', '60m', '90m', '1h', '1d', '5d', '1wk', '1mo', '3mo']]] + Data granularity. (provider: yfinance) + period : Optional[Union[Literal['1d', '5d', '1mo', '3mo', '6mo', '1y', '2y', '5y', '10y', 'ytd', 'max']]] + Period of the data to return. (provider: yfinance) + prepost : bool + Include Pre and Post market data. (provider: yfinance) + adjust : bool + Adjust all the data automatically. (provider: yfinance) + back_adjust : bool + Back-adjusted data to mimic true historical prices. (provider: yfinance) + + Returns + ------- + OBBject + results : Union[List[FuturesHistorical]] + Serializable results. + provider : Union[Literal['yfinance'], None] + Provider name. + warnings : Optional[List[Warning_]] + List of warnings. + chart : Optional[Chart] + Chart object. + extra: Dict[str, Any] + Extra info. + + FuturesHistorical + ----------------- + date : datetime + The date of the data. + open : float + The open price of the symbol. + high : float + The high price of the symbol. + low : float + The low price of the symbol. + close : float + The close price of the symbol. + volume : float + The volume of the symbol.""" # noqa: E501 + + inputs = filter_inputs( + provider_choices={ + "provider": provider, + }, + standard_params={ + "symbol": ",".join(symbol) if isinstance(symbol, list) else symbol, + "start_date": start_date, + "end_date": end_date, + "expiration": expiration, + }, + extra_params=kwargs, + ) + + return self._run( + "/futures/load", + **inputs, + ) diff --git a/openbb_platform/openbb/package/module_map.json b/openbb_platform/openbb/package/module_map.json index 75ffa6356bab..0cea51923361 100644 --- a/openbb_platform/openbb/package/module_map.json +++ b/openbb_platform/openbb/package/module_map.json @@ -2,13 +2,35 @@ "__extensions__": "", "crypto": "/crypto", "crypto_load": "/crypto/load", + "econometrics": "/econometrics", + "econometrics_bgot": "/econometrics/bgot", + "econometrics_coint": "/econometrics/coint", + "econometrics_corr": "/econometrics/corr", + "econometrics_dwat": "/econometrics/dwat", + "econometrics_granger": "/econometrics/granger", + "econometrics_ols": "/econometrics/ols", + "econometrics_ols_summary": "/econometrics/ols_summary", + "econometrics_panelbols": "/econometrics/panelbols", + "econometrics_panelfd": "/econometrics/panelfd", + "econometrics_panelfmac": "/econometrics/panelfmac", + "econometrics_panelols": "/econometrics/panelols", + "econometrics_panelpols": "/econometrics/panelpols", + "econometrics_panelre": "/econometrics/panelre", + "econometrics_unitroot": "/econometrics/unitroot", "economy": "/economy", "economy_available_indices": "/economy/available_indices", "economy_const": "/economy/const", + "economy_cot": "/economy/cot", + "economy_cot_search": "/economy/cot_search", "economy_cpi": "/economy/cpi", + "economy_european_index": "/economy/european_index", + "economy_european_index_constituents": "/economy/european_index_constituents", "economy_fred_index": "/economy/fred_index", "economy_index": "/economy/index", + "economy_index_search": "/economy/index_search", + "economy_index_snapshots": "/economy/index_snapshots", "economy_risk": "/economy/risk", + "economy_sp500_multiples": "/economy/sp500_multiples", "fixedincome": "/fixedincome", "fixedincome_ameribor": "/fixedincome/ameribor", "fixedincome_estr": "/fixedincome/estr", @@ -22,8 +44,22 @@ "forex": "/forex", "forex_load": "/forex/load", "forex_pairs": "/forex/pairs", + "futures": "/futures", + "futures_curve": "/futures/curve", + "futures_load": "/futures/load", "news": "/news", "news_globalnews": "/news/globalnews", + "qa": "/qa", + "qa_capm": "/qa/capm", + "qa_kurtosis": "/qa/kurtosis", + "qa_normality": "/qa/normality", + "qa_om": "/qa/om", + "qa_quantile": "/qa/quantile", + "qa_sh": "/qa/sh", + "qa_skew": "/qa/skew", + "qa_so": "/qa/so", + "qa_summary": "/qa/summary", + "qa_unitroot": "/qa/unitroot", "stocks": "/stocks", "stocks_ca": "/stocks/ca", "stocks_ca_peers": "/stocks/ca/peers", @@ -56,10 +92,39 @@ "stocks_fa_shrs": "/stocks/fa/shrs", "stocks_fa_split": "/stocks/fa/split", "stocks_fa_transcript": "/stocks/fa/transcript", + "stocks_info": "/stocks/info", "stocks_load": "/stocks/load", "stocks_multiples": "/stocks/multiples", "stocks_news": "/stocks/news", "stocks_options": "/stocks/options", "stocks_options_chains": "/stocks/options/chains", - "stocks_quote": "/stocks/quote" + "stocks_quote": "/stocks/quote", + "stocks_search": "/stocks/search", + "ta": "/ta", + "ta_ad": "/ta/ad", + "ta_adosc": "/ta/adosc", + "ta_adx": "/ta/adx", + "ta_aroon": "/ta/aroon", + "ta_atr": "/ta/atr", + "ta_bbands": "/ta/bbands", + "ta_cci": "/ta/cci", + "ta_cg": "/ta/cg", + "ta_clenow": "/ta/clenow", + "ta_cones": "/ta/cones", + "ta_demark": "/ta/demark", + "ta_donchian": "/ta/donchian", + "ta_ema": "/ta/ema", + "ta_fib": "/ta/fib", + "ta_fisher": "/ta/fisher", + "ta_hma": "/ta/hma", + "ta_ichimoku": "/ta/ichimoku", + "ta_kc": "/ta/kc", + "ta_macd": "/ta/macd", + "ta_obv": "/ta/obv", + "ta_rsi": "/ta/rsi", + "ta_sma": "/ta/sma", + "ta_stoch": "/ta/stoch", + "ta_vwap": "/ta/vwap", + "ta_wma": "/ta/wma", + "ta_zlma": "/ta/zlma" } \ No newline at end of file diff --git a/openbb_platform/openbb/package/qa.py b/openbb_platform/openbb/package/qa.py new file mode 100644 index 000000000000..0be073b7b4c3 --- /dev/null +++ b/openbb_platform/openbb/package/qa.py @@ -0,0 +1,391 @@ +### THIS FILE IS AUTO-GENERATED. DO NOT EDIT. ### + +from typing import List, Literal, Union + +import pandas +import typing_extensions +from annotated_types import Ge, Gt +from openbb_core.app.model.obbject import OBBject +from openbb_core.app.static.container import Container +from openbb_core.app.static.decorators import validate +from openbb_core.app.static.filters import filter_inputs +from openbb_provider.abstract.data import Data +from openbb_qa.qa_models import ( + CAPMModel, + NormalityModel, + OmegaModel, + SummaryModel, + UnitRootModel, +) + + +class ROUTER_qa(Container): + """/qa + capm + kurtosis + normality + om + quantile + sh + skew + so + summary + unitroot + """ + + def __repr__(self) -> str: + return self.__doc__ or "" + + @validate(config=dict(arbitrary_types_allowed=True)) + def capm( + self, data: Union[List[Data], pandas.DataFrame], target: str + ) -> OBBject[CAPMModel]: + """Get Capital Asset Pricing Model.""" # noqa: E501 + + inputs = filter_inputs( + data=data, + target=target, + ) + + return self._run( + "/qa/capm", + **inputs, + ) + + @validate(config=dict(arbitrary_types_allowed=True)) + def kurtosis( + self, + data: Union[List[Data], pandas.DataFrame], + target: str, + window: typing_extensions.Annotated[int, Gt(gt=0)], + ) -> OBBject[List[Data]]: + """Get the Kurtosis. + + Parameters + ---------- + data : List[Data] + Time series data. + target : str + Target column name. + window : PositiveInt + Window size. + + Returns + ------- + OBBject[List[Data]] + Kurtosis. + """ # noqa: E501 + + inputs = filter_inputs( + data=data, + target=target, + window=window, + ) + + return self._run( + "/qa/kurtosis", + **inputs, + ) + + @validate(config=dict(arbitrary_types_allowed=True)) + def normality( + self, data: Union[List[Data], pandas.DataFrame], target: str + ) -> OBBject[NormalityModel]: + """Get Normality Statistics. + + - **Kurtosis**: whether the kurtosis of a sample differs from the normal distribution. + - **Skewness**: whether the skewness of a sample differs from the normal distribution. + - **Jarque-Bera**: whether the sample data has the skewness and kurtosis matching a normal distribution. + - **Shapiro-Wilk**: whether a random sample comes from a normal distribution. + - **Kolmogorov-Smirnov**: whether two underlying one-dimensional probability distributions differ. + + Parameters + ---------- + data : List[Data] + Time series data. + target : str + Target column name. + + Returns + ------- + OBBject[NormalityModel] + Normality tests summary. See qa_models.NormalityModel for details. + """ # noqa: E501 + + inputs = filter_inputs( + data=data, + target=target, + ) + + return self._run( + "/qa/normality", + **inputs, + ) + + @validate(config=dict(arbitrary_types_allowed=True)) + def om( + self, + data: Union[List[Data], pandas.DataFrame], + target: str, + threshold_start: float = 0.0, + threshold_end: float = 1.5, + ) -> OBBject[List[OmegaModel]]: + """Calculate the Omega Ratio. + + Parameters + ---------- + data : List[Data] + Time series data. + target : str + Target column name. + threshold_start : float, optional + Start threshold, by default 0.0 + threshold_end : float, optional + End threshold, by default 1.5 + + Returns + ------- + OBBject[List[OmegaModel]] + Omega ratios. + """ # noqa: E501 + + inputs = filter_inputs( + data=data, + target=target, + threshold_start=threshold_start, + threshold_end=threshold_end, + ) + + return self._run( + "/qa/om", + **inputs, + ) + + @validate(config=dict(arbitrary_types_allowed=True)) + def quantile( + self, + data: Union[List[Data], pandas.DataFrame], + target: str, + window: typing_extensions.Annotated[int, Gt(gt=0)], + quantile_pct: typing_extensions.Annotated[float, Ge(ge=0)] = 0.5, + ) -> OBBject[List[Data]]: + """Get Quantile. + + Parameters + ---------- + data : List[Data] + Time series data. + target : str + Target column name. + window : PositiveInt + Window size. + quantile_pct : NonNegativeFloat, optional + Quantile percentage, by default 0.5 + + Returns + ------- + OBBject[List[Data]] + Quantile. + """ # noqa: E501 + + inputs = filter_inputs( + data=data, + target=target, + window=window, + quantile_pct=quantile_pct, + ) + + return self._run( + "/qa/quantile", + **inputs, + ) + + @validate(config=dict(arbitrary_types_allowed=True)) + def sh( + self, + data: Union[List[Data], pandas.DataFrame], + target: str, + rfr: float = 0.0, + window: typing_extensions.Annotated[int, Gt(gt=0)] = 252, + ) -> OBBject[List[Data]]: + """Get Sharpe Ratio. + + Parameters + ---------- + data : List[Data] + Time series data. + target : str + Target column name. + rfr : float, optional + Risk-free rate, by default 0.0 + window : PositiveInt, optional + Window size, by default 252 + + Returns + ------- + OBBject[List[Data]] + Sharpe ratio. + """ # noqa: E501 + + inputs = filter_inputs( + data=data, + target=target, + rfr=rfr, + window=window, + ) + + return self._run( + "/qa/sh", + **inputs, + ) + + @validate(config=dict(arbitrary_types_allowed=True)) + def skew( + self, + data: Union[List[Data], pandas.DataFrame], + target: str, + window: typing_extensions.Annotated[int, Gt(gt=0)], + ) -> OBBject[List[Data]]: + """Get Skewness. + + Parameters + ---------- + data : List[Data] + Time series data. + target : str + Target column name. + window : PositiveInt + Window size. + + Returns + ------- + OBBject[List[Data]] + Skewness. + """ # noqa: E501 + + inputs = filter_inputs( + data=data, + target=target, + window=window, + ) + + return self._run( + "/qa/skew", + **inputs, + ) + + @validate(config=dict(arbitrary_types_allowed=True)) + def so( + self, + data: Union[List[Data], pandas.DataFrame], + target: str, + target_return: float = 0.0, + window: typing_extensions.Annotated[int, Gt(gt=0)] = 252, + adjusted: bool = False, + ) -> OBBject[List[Data]]: + """Get Sortino Ratio. + + For method & terminology see: http://www.redrockcapital.com/Sortino__A__Sharper__Ratio_Red_Rock_Capital.pdf + + Parameters + ---------- + data : List[Data] + Time series data. + target : str + Target column name. + target_return : float, optional + Target return, by default 0.0 + window : PositiveInt, optional + Window size, by default 252 + adjusted : bool, optional + Adjust sortino ratio to compare it to sharpe ratio, by default False + + Returns + ------- + OBBject[List[Data]] + Sortino ratio. + """ # noqa: E501 + + inputs = filter_inputs( + data=data, + target=target, + target_return=target_return, + window=window, + adjusted=adjusted, + ) + + return self._run( + "/qa/so", + **inputs, + ) + + @validate(config=dict(arbitrary_types_allowed=True)) + def summary( + self, data: Union[List[Data], pandas.DataFrame], target: str + ) -> OBBject[SummaryModel]: + """Get Summary Statistics. + + Parameters + ---------- + data : List[Data] + Time series data. + target : str + Target column name. + + Returns + ------- + OBBject[SummaryModel] + Summary table. + """ # noqa: E501 + + inputs = filter_inputs( + data=data, + target=target, + ) + + return self._run( + "/qa/summary", + **inputs, + ) + + @validate(config=dict(arbitrary_types_allowed=True)) + def unitroot( + self, + data: Union[List[Data], pandas.DataFrame], + target: str, + fuller_reg: Literal["c", "ct", "ctt", "nc", "c"] = "c", + kpss_reg: Literal["c", "ct"] = "c", + ) -> OBBject[UnitRootModel]: + """Get Unit Root Test. + + Augmented Dickey-Fuller test for unit root. + Kwiatkowski-Phillips-Schmidt-Shin test for unit root. + + Parameters + ---------- + data : List[Data] + Time series data. + target : str + Target column name. + fuller_reg : Literal["c", "ct", "ctt", "nc", "c"] + Regression type for ADF test. + kpss_reg : Literal["c", "ct"] + Regression type for KPSS test. + + Returns + ------- + OBBject[UnitRootModel] + Unit root tests summary. + """ # noqa: E501 + + inputs = filter_inputs( + data=data, + target=target, + fuller_reg=fuller_reg, + kpss_reg=kpss_reg, + ) + + return self._run( + "/qa/unitroot", + **inputs, + ) diff --git a/openbb_platform/openbb/package/stocks.py b/openbb_platform/openbb/package/stocks.py index 0c01307e391e..d747df5f3d91 100644 --- a/openbb_platform/openbb/package/stocks.py +++ b/openbb_platform/openbb/package/stocks.py @@ -17,11 +17,13 @@ class ROUTER_stocks(Container): """/stocks /ca /fa + info load multiples news /options quote + search """ def __repr__(self) -> str: @@ -39,6 +41,121 @@ def fa(self): # route = "/stocks/fa" return stocks_fa.ROUTER_stocks_fa(command_runner=self._command_runner) + @validate + def info( + self, + symbol: typing_extensions.Annotated[ + Union[str, List[str]], + OpenBBCustomParameter(description="Symbol to get data for."), + ], + provider: Union[Literal["cboe"], None] = None, + **kwargs + ) -> OBBject[List[Data]]: + """Get general price and performance metrics of a stock. + + Parameters + ---------- + symbol : str + Symbol to get data for. + provider : Union[Literal['cboe'], None] + The provider to use for the query, by default None. + If None, the provider specified in defaults is selected or 'cboe' if there is + no default. + + Returns + ------- + OBBject + results : Union[List[StockInfo]] + Serializable results. + provider : Union[Literal['cboe'], None] + Provider name. + warnings : Optional[List[Warning_]] + List of warnings. + chart : Optional[Chart] + Chart object. + extra: Dict[str, Any] + Extra info. + + StockInfo + --------- + symbol : str + Symbol to get data for. + name : str + Name associated with the ticker symbol. + price : Optional[Union[float]] + Last transaction price. + open : Optional[Union[float]] + Opening price of the stock. + high : Optional[Union[float]] + High price of the current trading day. + low : Optional[Union[float]] + Low price of the current trading day. + close : Optional[Union[float]] + Closing price of the most recent trading day. + change : Optional[Union[float]] + Change in price over the current trading period. + change_percent : Optional[Union[float]] + Percent change in price over the current trading period. + prev_close : Optional[Union[float]] + Previous closing price. + type : Optional[Union[str]] + Type of asset. (provider: cboe) + exchange_id : Optional[Union[int]] + The Exchange ID number. (provider: cboe) + tick : Optional[Union[str]] + Whether the last sale was an up or down tick. (provider: cboe) + bid : Optional[Union[float]] + Current bid price. (provider: cboe) + bid_size : Optional[Union[float]] + Bid lot size. (provider: cboe) + ask : Optional[Union[float]] + Current ask price. (provider: cboe) + ask_size : Optional[Union[float]] + Ask lot size. (provider: cboe) + volume : Optional[Union[float]] + Stock volume for the current trading day. (provider: cboe) + iv30 : Optional[Union[float]] + The 30-day implied volatility of the stock. (provider: cboe) + iv30_change : Optional[Union[float]] + Change in 30-day implied volatility of the stock. (provider: cboe) + last_trade_timestamp : Optional[Union[datetime]] + Last trade timestamp for the stock. (provider: cboe) + iv30_annual_high : Optional[Union[float]] + The 1-year high of implied volatility. (provider: cboe) + hv30_annual_high : Optional[Union[float]] + The 1-year high of realized volatility. (provider: cboe) + iv30_annual_low : Optional[Union[float]] + The 1-year low of implied volatility. (provider: cboe) + hv30_annual_low : Optional[Union[float]] + The 1-year low of realized volatility. (provider: cboe) + iv60_annual_high : Optional[Union[float]] + The 60-day high of implied volatility. (provider: cboe) + hv60_annual_high : Optional[Union[float]] + The 60-day high of realized volatility. (provider: cboe) + iv60_annual_low : Optional[Union[float]] + The 60-day low of implied volatility. (provider: cboe) + hv60_annual_low : Optional[Union[float]] + The 60-day low of realized volatility. (provider: cboe) + iv90_annual_high : Optional[Union[float]] + The 90-day high of implied volatility. (provider: cboe) + hv90_annual_high : Optional[Union[float]] + The 90-day high of realized volatility. (provider: cboe)""" # noqa: E501 + + inputs = filter_inputs( + provider_choices={ + "provider": provider, + }, + standard_params={ + "symbol": ",".join(symbol) if isinstance(symbol, list) else symbol, + }, + extra_params=kwargs, + ) + + return self._run( + "/stocks/info", + **inputs, + ) + @validate def load( self, @@ -58,7 +175,11 @@ def load( description="End date of the data, in YYYY-MM-DD format." ), ] = None, - provider: Union[Literal["fmp", "intrinio", "polygon"], None] = None, + chart: bool = False, + provider: Union[ + Literal["alpha_vantage", "cboe", "fmp", "intrinio", "polygon", "yfinance"], + None, + ] = None, **kwargs ) -> OBBject[List[Data]]: """Load stock data for a specific ticker. @@ -71,14 +192,28 @@ def load( Start date of the data, in YYYY-MM-DD format. end_date : Union[datetime.date, None] End date of the data, in YYYY-MM-DD format. - provider : Union[Literal['fmp', 'intrinio', 'polygon'], None] + chart : bool + Whether to create a chart or not, by default False. + provider : Union[Literal['alpha_vantage', 'cboe', 'fmp', 'intrinio', 'polygo... The provider to use for the query, by default None. - If None, the provider specified in defaults is selected or 'fmp' if there is + If None, the provider specified in defaults is selected or 'alpha_vantage' if there is no default. + function_ : Literal['TIME_SERIES_INTRADAY', 'TIME_SERIES_DAILY', 'TIME_SERIES_WEEKLY', 'TIME_SERIES_MONTHLY', 'TIME_SERIES_DAILY_ADJUSTED', 'TIME_SERIES_WEEKLY_ADJUSTED', 'TIME_SERIES_MONTHLY_ADJUSTED'] + The time series of your choice. (provider: alpha_vantage) + period : Optional[Union[Literal['intraday', 'daily', 'weekly', 'monthly'], Literal['1d', '5d', '1mo', '3mo', '6mo', '1y', '2y', '5y', '10y', 'ytd', 'max']]] + Period of the data to return. (provider: alpha_vantage, yfinance) + interval : Optional[Union[Literal['1min', '5min', '15min', '30min', '60min'], Literal['1d', '1m'], Literal['1min', '5min', '15min', '30min', '1hour', '4hour', '1day'], Literal['1m', '2m', '5m', '15m', '30m', '60m', '90m', '1h', '1d', '5d', '1wk', '1mo', '3mo']]] + Data granularity. (provider: alpha_vantage, cboe, fmp, yfinance) + adjusted : Optional[Union[bool]] + Output time series is adjusted by historical split and dividend events. (provider: alpha_vantage, polygon) + extended_hours : Optional[Union[bool]] + Extended trading hours during pre-market and after-hours. (provider: alpha_vantage) + month : Optional[Union[str]] + Query a specific month in history (in YYYY-MM format). (provider: alpha_vantage) + outputsize : Optional[Union[Literal['compact', 'full']]] + Compact returns only the latest 100 data points in the intraday time series; full returns trailing 30 days of the most recent intraday data if the month parameter (see above) is not specified, or the full intraday data for a specific month in history if the month parameter is specified. (provider: alpha_vantage) timeseries : Optional[Union[typing_extensions.Annotated[int, Ge(ge=0)]]] Number of days to look back. (provider: fmp) - interval : Literal['1min', '5min', '15min', '30min', '1hour', '4hour', '1day'] - Data granularity. (provider: fmp) timezone : Optional[Union[Literal['Africa/Algiers', 'Africa/Cairo', 'Africa/Casablanca', 'Africa/Harare', 'Africa/Johannesburg', 'Africa/Monrovia', 'Africa/Nairobi', 'America/Argentina/Buenos_Aires', 'America/Bogota', 'America/Caracas', 'America/Chicago', 'America/Chihuahua', 'America/Denver', 'America/Godthab', 'America/Guatemala', 'America/Guyana', 'America/Halifax', 'America/Indiana/Indianapolis', 'America/Juneau', 'America/La_Paz', 'America/Lima', 'America/Lima', 'America/Los_Angeles', 'America/Mazatlan', 'America/Mexico_City', 'America/Mexico_City', 'America/Monterrey', 'America/Montevideo', 'America/New_York', 'America/Phoenix', 'America/Regina', 'America/Santiago', 'America/Sao_Paulo', 'America/St_Johns', 'America/Tijuana', 'Asia/Almaty', 'Asia/Baghdad', 'Asia/Baku', 'Asia/Bangkok', 'Asia/Bangkok', 'Asia/Chongqing', 'Asia/Colombo', 'Asia/Dhaka', 'Asia/Dhaka', 'Asia/Hong_Kong', 'Asia/Irkutsk', 'Asia/Jakarta', 'Asia/Jerusalem', 'Asia/Kabul', 'Asia/Kamchatka', 'Asia/Karachi', 'Asia/Karachi', 'Asia/Kathmandu', 'Asia/Kolkata', 'Asia/Kolkata', 'Asia/Kolkata', 'Asia/Kolkata', 'Asia/Krasnoyarsk', 'Asia/Kuala_Lumpur', 'Asia/Kuwait', 'Asia/Magadan', 'Asia/Muscat', 'Asia/Muscat', 'Asia/Novosibirsk', 'Asia/Rangoon', 'Asia/Riyadh', 'Asia/Seoul', 'Asia/Shanghai', 'Asia/Singapore', 'Asia/Srednekolymsk', 'Asia/Taipei', 'Asia/Tashkent', 'Asia/Tbilisi', 'Asia/Tehran', 'Asia/Tokyo', 'Asia/Tokyo', 'Asia/Tokyo', 'Asia/Ulaanbaatar', 'Asia/Urumqi', 'Asia/Vladivostok', 'Asia/Yakutsk', 'Asia/Yekaterinburg', 'Asia/Yerevan', 'Atlantic/Azores', 'Atlantic/Cape_Verde', 'Atlantic/South_Georgia', 'Australia/Adelaide', 'Australia/Brisbane', 'Australia/Darwin', 'Australia/Hobart', 'Australia/Melbourne', 'Australia/Melbourne', 'Australia/Perth', 'Australia/Sydney', 'Etc/UTC', 'UTC', 'Europe/Amsterdam', 'Europe/Athens', 'Europe/Belgrade', 'Europe/Berlin', 'Europe/Berlin', 'Europe/Bratislava', 'Europe/Brussels', 'Europe/Bucharest', 'Europe/Budapest', 'Europe/Copenhagen', 'Europe/Dublin', 'Europe/Helsinki', 'Europe/Istanbul', 'Europe/Kaliningrad', 'Europe/Kiev', 'Europe/Lisbon', 'Europe/Ljubljana', 'Europe/London', 'Europe/London', 'Europe/Madrid', 'Europe/Minsk', 'Europe/Moscow', 'Europe/Moscow', 'Europe/Paris', 'Europe/Prague', 'Europe/Riga', 'Europe/Rome', 'Europe/Samara', 'Europe/Sarajevo', 'Europe/Skopje', 'Europe/Sofia', 'Europe/Stockholm', 'Europe/Tallinn', 'Europe/Vienna', 'Europe/Vilnius', 'Europe/Volgograd', 'Europe/Warsaw', 'Europe/Zagreb', 'Pacific/Apia', 'Pacific/Auckland', 'Pacific/Auckland', 'Pacific/Chatham', 'Pacific/Fakaofo', 'Pacific/Fiji', 'Pacific/Guadalcanal', 'Pacific/Guam', 'Pacific/Honolulu', 'Pacific/Majuro', 'Pacific/Midway', 'Pacific/Midway', 'Pacific/Noumea', 'Pacific/Pago_Pago', 'Pacific/Port_Moresby', 'Pacific/Tongatapu']]] Returns trading times in this timezone. (provider: intrinio) source : Optional[Union[Literal['realtime', 'delayed', 'nasdaq_basic']]] @@ -97,15 +232,33 @@ def load( Sort order of the data. (provider: polygon) limit : int The number of data entries to return. (provider: polygon) - adjusted : bool - Output time series is adjusted by historical split and dividend events. (provider: polygon) + prepost : bool + Include Pre and Post market data. (provider: yfinance) + actions : bool + Include actions. (provider: yfinance) + auto_adjust : bool + Adjust all OHLC data automatically. (provider: yfinance) + back_adjust : bool + Attempt to adjust all the data automatically. (provider: yfinance) + progress : bool + Show progress bar. (provider: yfinance) + ignore_tz : bool + When combining from different timezones, ignore that part of datetime. (provider: yfinance) + rounding : bool + Round to two decimal places? (provider: yfinance) + repair : bool + Detect currency unit 100x mixups and attempt repair. (provider: yfinance) + keepna : bool + Keep NaN rows returned by Yahoo? (provider: yfinance) + group_by : Literal['ticker', 'column'] + Group by ticker or column. (provider: yfinance) Returns ------- OBBject results : Union[List[StockHistorical]] Serializable results. - provider : Union[Literal['fmp', 'intrinio', 'polygon'], None] + provider : Union[Literal['alpha_vantage', 'cboe', 'fmp', 'intrinio', 'polygon', 'yfinance'], None] Provider name. warnings : Optional[List[Warning_]] List of warnings. @@ -130,8 +283,18 @@ def load( The volume of the symbol. vwap : Optional[Union[typing_extensions.Annotated[float, Gt(gt=0)]]] Volume Weighted Average Price of the symbol. - adj_close : Optional[Union[float]] - Adjusted Close Price of the symbol. (provider: fmp) + adj_close : Optional[Union[typing_extensions.Annotated[float, Gt(gt=0)], float]] + The adjusted close price of the symbol. (provider: alpha_vantage, fmp) + dividend_amount : Optional[Union[typing_extensions.Annotated[float, Ge(ge=0)]]] + Dividend amount paid for the corresponding date. (provider: alpha_vantage) + split_coefficient : Optional[Union[typing_extensions.Annotated[float, Ge(ge=0)]]] + Split coefficient for the corresponding date. (provider: alpha_vantage) + calls_volume : Optional[Union[float]] + Number of calls traded during the most recent trading period. Only valid if interval is 1m. (provider: cboe) + puts_volume : Optional[Union[float]] + Number of puts traded during the most recent trading period. Only valid if interval is 1m. (provider: cboe) + total_options_volume : Optional[Union[float]] + Total number of options traded during the most recent trading period. Only valid if interval is 1m. (provider: cboe) unadjusted_volume : Optional[Union[float]] Unadjusted volume of the symbol. (provider: fmp) change : Optional[Union[float]] @@ -162,6 +325,7 @@ def load( "end_date": end_date, }, extra_params=kwargs, + chart=chart, ) return self._run( @@ -180,6 +344,7 @@ def multiples( Union[int, None], OpenBBCustomParameter(description="The number of data entries to return."), ] = 100, + chart: bool = False, provider: Union[Literal["fmp"], None] = None, **kwargs ) -> OBBject[List[Data]]: @@ -191,6 +356,8 @@ def multiples( Symbol to get data for. limit : Union[int, None] The number of data entries to return. + chart : bool + Whether to create a chart or not, by default False. provider : Union[Literal['fmp'], None] The provider to use for the query, by default None. If None, the provider specified in defaults is selected or 'fmp' if there is @@ -342,6 +509,7 @@ def multiples( "limit": limit, }, extra_params=kwargs, + chart=chart, ) return self._run( @@ -359,7 +527,10 @@ def news( Union[typing_extensions.Annotated[int, Ge(ge=0)], None], OpenBBCustomParameter(description="Number of results to return per page."), ] = 20, - provider: Union[Literal["benzinga", "fmp", "intrinio", "polygon"], None] = None, + chart: bool = False, + provider: Union[ + Literal["benzinga", "fmp", "intrinio", "polygon", "yfinance"], None + ] = None, **kwargs ) -> OBBject[List[Data]]: """Get news for one or more stock tickers. @@ -370,7 +541,9 @@ def news( Comma separated list of symbols. limit : Union[typing_extensions.Annotated[int, Ge(ge=0)], None] Number of results to return per page. - provider : Union[Literal['benzinga', 'fmp', 'intrinio', 'polygon'], None] + chart : bool + Whether to create a chart or not, by default False. + provider : Union[Literal['benzinga', 'fmp', 'intrinio', 'polygon', 'yfinance... The provider to use for the query, by default None. If None, the provider specified in defaults is selected or 'benzinga' if there is no default. @@ -410,7 +583,7 @@ def news( OBBject results : Union[List[StockNews]] Serializable results. - provider : Union[Literal['benzinga', 'fmp', 'intrinio', 'polygon'], None] + provider : Union[Literal['benzinga', 'fmp', 'intrinio', 'polygon', 'yfinance'], None] Provider name. warnings : Optional[List[Warning_]] List of warnings. @@ -457,10 +630,18 @@ def news( Image URL. (provider: polygon) keywords : Optional[Union[List[str]]] Keywords in the article (provider: polygon) - publisher : Optional[Union[openbb_polygon.models.stock_news.PolygonPublisher]] - Publisher of the article. (provider: polygon) + publisher : Optional[Union[openbb_polygon.models.stock_news.PolygonPublisher, str]] + Publisher of the article. (provider: polygon, yfinance) tickers : Optional[Union[List[str]]] - Tickers covered in the article. (provider: polygon)""" # noqa: E501 + Tickers covered in the article. (provider: polygon) + uuid : Optional[Union[str]] + Unique identifier for the news article (provider: yfinance) + type : Optional[Union[str]] + Type of the news article (provider: yfinance) + thumbnail : Optional[Union[List]] + Thumbnail related data to the ticker news article. (provider: yfinance) + related_tickers : Optional[Union[str]] + Tickers related to the news article. (provider: yfinance)""" # noqa: E501 inputs = filter_inputs( provider_choices={ @@ -471,6 +652,7 @@ def news( "limit": limit, }, extra_params=kwargs, + chart=chart, ) return self._run( @@ -626,3 +808,70 @@ def quote( "/stocks/quote", **inputs, ) + + @validate + def search( + self, + query: typing_extensions.Annotated[ + str, OpenBBCustomParameter(description="Search query.") + ] = "", + is_symbol: typing_extensions.Annotated[ + bool, + OpenBBCustomParameter(description="Whether to search by ticker symbol."), + ] = False, + provider: Union[Literal["cboe"], None] = None, + **kwargs + ) -> OBBject[List[Data]]: + """Search for a company or stock ticker. + + Parameters + ---------- + query : str + Search query. + is_symbol : bool + Whether to search by ticker symbol. + provider : Union[Literal['cboe'], None] + The provider to use for the query, by default None. + If None, the provider specified in defaults is selected or 'cboe' if there is + no default. + + Returns + ------- + OBBject + results : Union[List[StockSearch]] + Serializable results. + provider : Union[Literal['cboe'], None] + Provider name. + warnings : Optional[List[Warning_]] + List of warnings. + chart : Optional[Chart] + Chart object. + extra: Dict[str, Any] + Extra info. + + StockSearch + ----------- + symbol : str + Symbol to get data for. + name : str + Name of the company. + dpm_name : Optional[Union[str]] + Name of the primary market maker. (provider: cboe) + post_station : Optional[Union[str]] + Post and station location on the CBOE trading floor. (provider: cboe)""" # noqa: E501 + + inputs = filter_inputs( + provider_choices={ + "provider": provider, + }, + standard_params={ + "query": query, + "is_symbol": is_symbol, + }, + extra_params=kwargs, + ) + + return self._run( + "/stocks/search", + **inputs, + ) diff --git a/openbb_platform/openbb/package/stocks_fa.py b/openbb_platform/openbb/package/stocks_fa.py index c83dd24cc4aa..c6b1e84cf32e 100644 --- a/openbb_platform/openbb/package/stocks_fa.py +++ b/openbb_platform/openbb/package/stocks_fa.py @@ -62,7 +62,7 @@ def balance( int, OpenBBCustomParameter(description="The number of data entries to return."), ] = 12, - provider: Union[Literal["fmp", "intrinio", "polygon"], None] = None, + provider: Union[Literal["fmp", "intrinio", "polygon", "yfinance"], None] = None, **kwargs ) -> OBBject[List[Data]]: """Balance Sheet. @@ -75,7 +75,7 @@ def balance( Period of the data to return. limit : int The number of data entries to return. - provider : Union[Literal['fmp', 'intrinio', 'polygon'], None] + provider : Union[Literal['fmp', 'intrinio', 'polygon', 'yfinance'], None] The provider to use for the query, by default None. If None, the provider specified in defaults is selected or 'fmp' if there is no default. @@ -123,7 +123,7 @@ def balance( OBBject results : Union[List[BalanceSheet]] Serializable results. - provider : Union[Literal['fmp', 'intrinio', 'polygon'], None] + provider : Union[Literal['fmp', 'intrinio', 'polygon', 'yfinance'], None] Provider name. warnings : Optional[List[Warning_]] List of warnings. @@ -505,7 +505,7 @@ def cash( int, OpenBBCustomParameter(description="The number of data entries to return."), ] = 12, - provider: Union[Literal["fmp", "intrinio", "polygon"], None] = None, + provider: Union[Literal["fmp", "intrinio", "polygon", "yfinance"], None] = None, **kwargs ) -> OBBject[List[Data]]: """Cash Flow Statement. @@ -518,7 +518,7 @@ def cash( Period of the data to return. limit : int The number of data entries to return. - provider : Union[Literal['fmp', 'intrinio', 'polygon'], None] + provider : Union[Literal['fmp', 'intrinio', 'polygon', 'yfinance'], None] The provider to use for the query, by default None. If None, the provider specified in defaults is selected or 'fmp' if there is no default. @@ -566,7 +566,7 @@ def cash( OBBject results : Union[List[CashFlowStatement]] Serializable results. - provider : Union[Literal['fmp', 'intrinio', 'polygon'], None] + provider : Union[Literal['fmp', 'intrinio', 'polygon', 'yfinance'], None] Provider name. warnings : Optional[List[Warning_]] List of warnings. @@ -1388,7 +1388,7 @@ def income( int, OpenBBCustomParameter(description="The number of data entries to return."), ] = 12, - provider: Union[Literal["fmp", "intrinio", "polygon"], None] = None, + provider: Union[Literal["fmp", "intrinio", "polygon", "yfinance"], None] = None, **kwargs ) -> OBBject[List[Data]]: """Income Statement. @@ -1401,7 +1401,7 @@ def income( Period of the data to return. limit : int The number of data entries to return. - provider : Union[Literal['fmp', 'intrinio', 'polygon'], None] + provider : Union[Literal['fmp', 'intrinio', 'polygon', 'yfinance'], None] The provider to use for the query, by default None. If None, the provider specified in defaults is selected or 'fmp' if there is no default. @@ -1449,7 +1449,7 @@ def income( OBBject results : Union[List[IncomeStatement]] Serializable results. - provider : Union[Literal['fmp', 'intrinio', 'polygon'], None] + provider : Union[Literal['fmp', 'intrinio', 'polygon', 'yfinance'], None] Provider name. warnings : Optional[List[Warning_]] List of warnings. diff --git a/openbb_platform/openbb/package/stocks_options.py b/openbb_platform/openbb/package/stocks_options.py index 710a1d874ac2..ef9cb5bb6f22 100644 --- a/openbb_platform/openbb/package/stocks_options.py +++ b/openbb_platform/openbb/package/stocks_options.py @@ -26,7 +26,7 @@ def chains( Union[str, List[str]], OpenBBCustomParameter(description="Symbol to get data for."), ], - provider: Union[Literal["intrinio"], None] = None, + provider: Union[Literal["cboe", "intrinio"], None] = None, **kwargs ) -> OBBject[List[Data]]: """Get the complete options chain for a ticker. @@ -35,11 +35,11 @@ def chains( ---------- symbol : str Symbol to get data for. - provider : Union[Literal['intrinio'], None] + provider : Union[Literal['cboe', 'intrinio'], None] The provider to use for the query, by default None. - If None, the provider specified in defaults is selected or 'intrinio' if there is + If None, the provider specified in defaults is selected or 'cboe' if there is no default. - date : Optional[Union[str]] + date : Optional[Union[datetime.date]] Date for which the options chains are returned. (provider: intrinio) Returns @@ -47,7 +47,7 @@ def chains( OBBject results : Union[List[OptionsChains]] Serializable results. - provider : Union[Literal['intrinio'], None] + provider : Union[Literal['cboe', 'intrinio'], None] Provider name. warnings : Optional[List[Warning_]] List of warnings. @@ -60,15 +60,15 @@ def chains( ------------- contract_symbol : str Contract symbol for the option. - symbol : str + symbol : Union[str] Underlying symbol for the option. expiration : date Expiration date of the contract. strike : float Strike price of the contract. - type : str + option_type : str Call or Put. - date : date + eod_date : date Date for which the options chains are returned. close : Optional[Union[float]] Close price for the option that day. @@ -109,7 +109,29 @@ def chains( theta : Optional[Union[float]] Theta of the option. vega : Optional[Union[float]] - Vega of the option.""" # noqa: E501 + Vega of the option. + bid_size : Optional[Union[int]] + Bid size for the option. (provider: cboe) + ask_size : Optional[Union[int]] + Ask size for the option. (provider: cboe) + theoretical : Optional[Union[float]] + Theoretical value of the option. (provider: cboe) + last_trade_price : Optional[Union[float]] + Last trade price of the option. (provider: cboe) + tick : Optional[Union[str]] + Whether the last tick was up or down in price. (provider: cboe) + prev_close : Optional[Union[float]] + Previous closing price of the option. (provider: cboe) + change : Optional[Union[float]] + Change in price of the option. (provider: cboe) + change_percent : Optional[Union[float]] + Change, in percent, of the option. (provider: cboe) + rho : Optional[Union[float]] + Rho of the option. (provider: cboe) + last_trade_timestamp : Optional[Union[datetime]] + Last trade timestamp of the option. (provider: cboe) + dte : Optional[Union[int]] + Days to expiration for the option. (provider: cboe)""" # noqa: E501 inputs = filter_inputs( provider_choices={ diff --git a/openbb_platform/openbb/package/ta.py b/openbb_platform/openbb/package/ta.py new file mode 100644 index 000000000000..d080bc26eaf3 --- /dev/null +++ b/openbb_platform/openbb/package/ta.py @@ -0,0 +1,1485 @@ +### THIS FILE IS AUTO-GENERATED. DO NOT EDIT. ### + +from typing import List, Literal, Union + +import pandas +import typing_extensions +from annotated_types import Ge, Gt +from openbb_core.app.model.obbject import OBBject +from openbb_core.app.static.container import Container +from openbb_core.app.static.decorators import validate +from openbb_core.app.static.filters import filter_inputs +from openbb_provider.abstract.data import Data + + +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 = "adj_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 "adj_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, + ) diff --git a/openbb_platform/platform/provider/openbb_provider/standard_models/options_chains.py b/openbb_platform/platform/provider/openbb_provider/standard_models/options_chains.py index 218ad972a730..8ad30b2ba2a8 100644 --- a/openbb_platform/platform/provider/openbb_provider/standard_models/options_chains.py +++ b/openbb_platform/platform/provider/openbb_provider/standard_models/options_chains.py @@ -27,11 +27,11 @@ class OptionsChainsData(Data): """Options Chains Data.""" contract_symbol: str = Field(description="Contract symbol for the option.") - symbol: str = Field(description="Underlying symbol for the option.") + symbol: Optional[str] = Field(description="Underlying symbol for the option.") expiration: dateType = Field(description="Expiration date of the contract.") strike: float = Field(description="Strike price of the contract.") - type: str = Field(description="Call or Put.") - date: dateType = Field( + option_type: str = Field(description="Call or Put.") + eod_date: dateType = Field( description="Date for which the options chains are returned." ) diff --git a/openbb_platform/providers/intrinio/openbb_intrinio/models/options_chains.py b/openbb_platform/providers/intrinio/openbb_intrinio/models/options_chains.py index 57668d26c64a..ec79b7c9fd5f 100644 --- a/openbb_platform/providers/intrinio/openbb_intrinio/models/options_chains.py +++ b/openbb_platform/providers/intrinio/openbb_intrinio/models/options_chains.py @@ -1,19 +1,22 @@ """Intrinio Options Chains fetcher.""" +from concurrent.futures import ThreadPoolExecutor from datetime import ( + date as dateType, datetime, timedelta, ) +from itertools import repeat from typing import Any, Dict, List, Optional -from openbb_intrinio.utils.helpers import get_data_many -from openbb_intrinio.utils.references import TICKER_EXCEPTIONS +from dateutil import parser +from openbb_intrinio.utils.helpers import get_data_many, get_weekday from openbb_provider.abstract.fetcher import Fetcher from openbb_provider.standard_models.options_chains import ( OptionsChainsData, OptionsChainsQueryParams, ) -from pydantic import Field, validator +from pydantic import Field, field_validator class IntrinioOptionsChainsQueryParams(OptionsChainsQueryParams): @@ -22,7 +25,7 @@ class IntrinioOptionsChainsQueryParams(OptionsChainsQueryParams): source: https://docs.intrinio.com/documentation/web_api/get_options_chain_eod_v2 """ - date: Optional[str] = Field( + date: Optional[dateType] = Field( description="Date for which the options chains are returned." ) @@ -30,20 +33,18 @@ class IntrinioOptionsChainsQueryParams(OptionsChainsQueryParams): class IntrinioOptionsChainsData(OptionsChainsData): """Intrinio Options Chains Data.""" - __alias_dict__ = {"contract_symbol": "code", "symbol": "ticker"} + __alias_dict__ = { + "contract_symbol": "code", + "symbol": "ticker", + "eod_date": "date", + "option_type": "type", + } - @validator("expiration", "date", pre=True, check_fields=False) + @field_validator("expiration", "date", mode="before", check_fields=False) + @classmethod def date_validate(cls, v): # pylint: disable=E0213 """Return the datetime object from the date string""" - return datetime.strptime(v, "%Y-%m-%d") - - -def get_weekday(date: str) -> str: - """Return the weekday date.""" - strptime = datetime.strptime(date, "%Y-%m-%d") - if strptime.weekday() in [5, 6]: - date = (strptime - timedelta(days=strptime.weekday() - 4)).strftime("%Y-%m-%d") - return date + return parser.parse(v) class IntrinioOptionsChainsFetcher( @@ -70,36 +71,38 @@ def extract_data( ) -> List[Dict]: """Return the raw data from the Intrinio endpoint.""" api_key = credentials.get("intrinio_api_key") if credentials else "" + + data: List = [] base_url = "https://api-v2.intrinio.com/options" - if query.symbol in TICKER_EXCEPTIONS: - query.symbol = f"${query.symbol}" + def get_options_chains( + expiration: str, data: List[IntrinioOptionsChainsData] + ) -> None: + """Return the data for the given expiration.""" + url = ( + f"{base_url}/chain/{query.symbol}/{expiration}/eod?" + f"date={query.date}&api_key={api_key}" + ) + response = get_data_many(url, "chain", **kwargs) + data.extend(response) - def get_expirations(date: str) -> List[str]: - """Return the expirations for the given date.""" + def get_data(date: str) -> None: + """Fetch data for a given date using ThreadPoolExecutor.""" url = ( f"{base_url}/expirations/{query.symbol}/eod?" f"after={date}&api_key={api_key}" ) - return get_data_many(url, "expirations", **kwargs) + expirations = get_data_many(url, "expirations", **kwargs) - def get_data(expirations: List[str]) -> List[Dict]: - """Return the data for the given expiration.""" - data = [] - for expiration in expirations: - url = ( - f"{base_url}/chain/{query.symbol}/{expiration}/eod?" - f"date={query.date}&api_key={api_key}" - ) - response = get_data_many(url, "chain", **kwargs) - data.extend(response) - - return data - - if len(data := get_data(get_expirations(get_weekday(query.date)))) == 0: - data = get_data( - get_expirations(get_weekday(query.date - timedelta(days=1))) - ) + with ThreadPoolExecutor() as executor: + executor.map(get_options_chains, expirations, repeat(data)) + + date = get_weekday(query.date) + get_data(date) + + if not data: + date = get_weekday(query.date - timedelta(days=1)) + get_data(date) return data diff --git a/openbb_platform/providers/intrinio/openbb_intrinio/utils/helpers.py b/openbb_platform/providers/intrinio/openbb_intrinio/utils/helpers.py index 902c1fcca91b..83169ad7c0fd 100644 --- a/openbb_platform/providers/intrinio/openbb_intrinio/utils/helpers.py +++ b/openbb_platform/providers/intrinio/openbb_intrinio/utils/helpers.py @@ -1,6 +1,10 @@ """Intrinio Helpers Module.""" import json +from datetime import ( + date as dateType, + timedelta, +) from io import StringIO from typing import Any, List, Optional, TypeVar, Union @@ -116,3 +120,10 @@ def get_data_one(url: str, **kwargs: Any) -> dict: raise ValueError("Expected dict, got list of dicts") from e return data + + +def get_weekday(date: dateType) -> str: + """Return the weekday date.""" + if date.weekday() in [5, 6]: + return (date - timedelta(days=date.weekday() - 4)).strftime("%Y-%m-%d") + return date.strftime("%Y-%m-%d") diff --git a/openbb_platform/providers/intrinio/openbb_intrinio/utils/references.py b/openbb_platform/providers/intrinio/openbb_intrinio/utils/references.py index 545afa40741c..a0479f69c2da 100644 --- a/openbb_platform/providers/intrinio/openbb_intrinio/utils/references.py +++ b/openbb_platform/providers/intrinio/openbb_intrinio/utils/references.py @@ -12,20 +12,6 @@ "delayed_sip", ] -TICKER_EXCEPTIONS = [ - "SPX", - "XSP", - "XEO", - "NDX", - "XND", - "VIX", - "RUT", - "MRUT", - "DJX", - "XAU", - "OEX", -] - INTERVALS = Literal["1m", "5m", "10m", "15m", "30m", "60m", "1h"] TIMEZONES = Literal[